diff --git a/.gitignore b/.gitignore index c03f7bfa88..295b55d8a8 100644 --- a/.gitignore +++ b/.gitignore @@ -26,3 +26,4 @@ compiler/.lexlean/ # Claude Code worktrees and session state (never part of the release set). .claude/ +stdlib/.lexlean/ diff --git a/CHANGELOG.md b/CHANGELOG.md index 553841b72c..aa5bdebf69 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,22 @@ versions, and the entries below say what each tag does and does not claim. ## Unreleased +- The standard library's first member: bytes and text over `Bytes` + (SPEC.md §17.22, `SL-01`, #92; no new diagnostic code). `stdlib/` is a + language-1.2 project beside `compiler/` under the module prefix + `LexLeanStd`, written in the authoring notation; its `Text` module declares + `startsWith`, `endsWith`, `trim`, `lines`, `splitOn`, `joinWith`, and + `find` as production roots for `rust-std`, each admitting exactly the + effects its closure realizes. `SL-01` runs every member's lowered program + under the calculus evaluator and its rendered package under the pinned + rustc on a seeded corpus against Rust's `starts_with`, `ends_with`, + `trim_ascii`, `lines`, `split`, `join`, and `find`, detects a planted + character class in `trim`, and, under the pinned Lean, compares the + certified packages the production export publishes with the committed + ones under `tests/production-export/stdlib/`. The project passes the + example gates (`verify-examples`, `check-golden`) and + `check-production-export` compares its packages. `SL-01` brings the + register to 393 IDs. - The `bdd` recipe runs in CI as the parts of one run (SPEC.md §9.2, §9.4, `RP-13`, `RP-14`, #131; no new diagnostic code, no new ID). The `rest` leg took 111.5 minutes on the run that merged #152 (CI run 38905653756), 95.7 of diff --git a/CONFORMANCE.md b/CONFORMANCE.md index 62d80e7ecc..cc2ed414ea 100644 --- a/CONFORMANCE.md +++ b/CONFORMANCE.md @@ -512,6 +512,12 @@ the error registry does not sanction (R5, `ERRORS.md`). | `SM-30` | `build` | Language 1.2 graph literals reference only declared nodes, a graph's nodes are its keys and every successor, and successor, reachability, and topological-order queries are deterministic, bounded by the node count, and report a cycle as none. | | `SM-31` | `build` | Language 1.2 accepts a second native core-module schema, and only language 1.2 does, whose annotation nodes, extended names, definition safety and groups, compiled and reducibility state, and matcher, projection, no-confusion, simplification, equation-record, inlining, sparse-casesOn, and grind extension state are closed data that the linker validates against the kind of the declaration carrying it and bounds in depth by max_scope_depth, and that both backends render, and that the Lean backend's one fixed decoder submits through Lean's checked declaration API, so that the generated module elaborates under the pinned Lean with exactly its pinned axioms. | +## stdlib + +| ID | Level | Statement | +| --- | --- | --- | +| `SL-01` | `build` | The standard library's `Text` module is language-1.2 source whose seven members over `Bytes` (`startsWith`, `endsWith`, `trim`, `lines`, `splitOn`, `joinWith`, `find`) are production roots eligible for `rust-std` with exactly their declared effects; each member's lowered program under the calculus evaluator and its rendered `rust-std` package under the pinned rustc agree with Rust's `starts_with`, `ends_with`, `trim_ascii`, `lines`, `split`, `join`, and `find` on a seeded corpus; a planted defect in a member is detected; and the certified packages the production export publishes for it are the committed ones. | + ## tooling | ID | Level | Statement | diff --git a/README.md b/README.md index 9b53c9ab39..543d38581d 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 393 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. @@ -178,6 +178,7 @@ Every row is validated by `just vv`; the IDs link the claim to its register row, | Language-1.2 compiler-tooling modules: a closed, typed program over a registry of the external Lean interface (types with exact constructors and index requirements, calls with exact signatures), with flat index-exhaustive matching, licensed partial and mutual recursion, complete recursive traversal, command registration, invocation and evaluation as semantic data, both backends from one linked value, and no member that holds Lean text | `TL-01`..`TL-11` | `build` | | The language-1.2 authoring notation: a readable `.lex.tex` text for a semantic module, in bijection with its canonical JSON, whose every position and variant is read from the schema, with readable forms for types and terms and a generic form for every other value, formatted canonically by `fmt` (which also writes a module out of its data form), linking to exactly the module its data form links to, failing closed, the only form in which a language-1.2 source of the product is written, the same for the compiler-tooling modules in the generic notation, with no compiler-semantics ID that depends on which form an embedded module is written in, with no product source owned by a generator but five named records, read and written by programs only through the authoring API (`lexlean::sdk`), and, for a native core module, a readable program over the shared table of kernel terms whose numbering is the order of its text | `AU-01`..`AU-12` | `build` | | 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 literal `nat-add-zero` example, the Lean-verified feature examples, and the complete negative fixture suite | `EX-01`..`EX-08` | `build` | Range rows abbreviate consecutive registered IDs; every individual ID in each range is registered in [`model/ids.toml`](model/ids.toml) at the stated level with its own scenario and test. diff --git a/SPEC.md b/SPEC.md index 88f3f367da..74d39df5ea 100644 --- a/SPEC.md +++ b/SPEC.md @@ -6581,6 +6581,44 @@ relates the module's pieces to its text, and `fmt` writes a language-1.2 core module of schema 2 in the notation, so a module written as `\coredata` leaves the data form by being formatted. +### 17.22 The standard library + +The standard library is the project `stdlib/` beside `compiler/`: language-1.2 +source of the product, written in the authoring notation (§17.21) under the +module prefix `LexLeanStd`, whose members are production roots (§17.13). It is +not an example: it passes the gates of §28.6 as the compiler project does, its +production export (§24.7) is committed under `tests/production-export/stdlib/` +and compared by `cargo xtask check-production-export`, and a member is +validated by a differential before it is a member. The differential runs the +member's lowered program under the calculus evaluator (§17.14) and its +rendered `rust-std` package under the pinned rustc (§17.16) on a seeded corpus +against the function of Rust's standard library the member corresponds to, and +a member whose outcome differs from its oracle on any input is not committed. +A member's declaration admits exactly the effects its runtime closure realizes +on its target, so the eligibility report of every member is its own text. + +The first module, `Text`, is bytes and text over `Bytes`. A `String` has no +scalar iteration in language 1.2, so text is handled as its UTF-8 bytes, a +character class is a comparison of `UInt8` by `equal`, and a member that is +defined on text is defined on the bytes of valid UTF-8. Its members and their +oracles: + +| Member | Oracle | +| --- | --- | +| `startsWith (subject prefix : Bytes) : Bool` | `<[u8]>::starts_with` | +| `endsWith (subject suffix : Bytes) : Bool` | `<[u8]>::ends_with` | +| `trim (subject : Bytes) : Bytes` | `<[u8]>::trim_ascii` | +| `lines (subject : Bytes) : List Bytes` | `str::lines` on UTF-8 input: a line ends at `\n` or `\r\n`, and the last line needs no ending | +| `splitOn (subject : Bytes) (delimiter : UInt8) : List Bytes` | `<[u8]>::split` | +| `joinWith (pieces : List Bytes) (separator : Bytes) : Bytes` | `<[Vec]>::join` | +| `find (subject needle : Bytes) : Option Nat` | `str::find` on UTF-8 input, as a byte offset | + +Every scan is `iterate_until` under the subject's length as its fuel and every +accumulation is `list_fold`, so a member carries `recursion` exactly where it +realizes a library template, and no member recurses itself. Theorems over the +members wait for equality of `Bytes` by evaluation; until then the module's +behavior is held by the differential (`SL-01`). + ## 18. Lean backend ### 18.1 Output contract @@ -8727,7 +8765,7 @@ Tests MUST establish that LexLean rejects, at minimum: ### 28.6 Example verification -Every directory under `examples/` is discovered rather than listed. Each example MUST include its lock and expected platform-independent build outputs. `cargo xtask verify-examples` runs `fmt --check`, `lock --check`, `check`, `build`, and `verify`. The `compiler/` project (§17.14, §17.15) passes the same gates as an example. +Every directory under `examples/` is discovered rather than listed. Each example MUST include its lock and expected platform-independent build outputs. `cargo xtask verify-examples` runs `fmt --check`, `lock --check`, `check`, `build`, and `verify`. The `compiler/` project (§17.14, §17.15) and the `stdlib/` project (§17.22) pass the same gates as an example. --- @@ -9377,8 +9415,9 @@ 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 | +| `SL-01` | `stdlib` | The standard library's `Text` module is language-1.2 source whose seven members over `Bytes` (`startsWith`, `endsWith`, `trim`, `lines`, `splitOn`, `joinWith`, `find`) are production roots eligible for `rust-std` with exactly their declared effects; each member's lowered program under the calculus evaluator and its rendered `rust-std` package under the pinned rustc agree with Rust's `starts_with`, `ends_with`, `trim_ascii`, `lines`, `split`, `join`, and `find` on a seeded corpus; a planted defect in a member is detected; and the certified packages the production export publishes for it are the committed ones. | §17.22 | -**Total required capability IDs:** 392. +**Total required capability IDs:** 393. 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/VERIFICATION.md b/VERIFICATION.md index 7dda87b85e..f45a7bb1e7 100644 --- a/VERIFICATION.md +++ b/VERIFICATION.md @@ -8159,6 +8159,35 @@ 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. +### a standard-library member can fail its oracle (SPEC.md §17.22) + +`SL-01` holds every member of `LexLeanStd.Text` to the function of Rust's +standard library it corresponds to: the member's lowered program under the +calculus evaluator and its rendered `rust-std` package under the pinned rustc +are run on a seeded corpus (edge cases first, then random inputs over the +bytes the members distinguish), and one disagreement fails the case. The first +run of the case found a defect in the source and not in the differential: three +declarations admitted `overflow` their closures never realize, and the case +refused them before any run (`startsWith: the declared effects`, declared +`["allocation", "overflow"]`, realized `["allocation"]`); the declarations now +admit exactly what they realize. + +- **a character class off by one.** `isSpace` takes the vertical tab (`11`) + for white space in place of the form feed (`12`), so `trim` keeps a form + feed and strips a vertical tab, which `<[u8]>::trim_ascii` never does. + `-- conformance_sl_01`: + + ```text + panicked at crates/conformance/src/cases/stdlib.rs:483:17: + trim: the evaluator and Rust's standard library disagree on 431 of 600 runs: ["run 4 on [Bytes { hex: \"0b2061200b\" }]: {\"hex\":\"61\",\"kind\":\"bytes\"} != {\"hex\":\"0b2061200b\",\"kind\":\"bytes\"}", …] + ``` + + The same plant is made by the case itself on a copy of the project on every + run, so the gate stays armed: a corpus that no longer reaches the vertical + tab or the form feed fails the case. + +Removed: the source was restored; `conformance_sl_01` passes, in 156 s with +the production export of the seven members under the pinned Lean. ## The `bdd` recipe as the parts of one run (Issue #131) diff --git a/crates/conformance/src/cases/mod.rs b/crates/conformance/src/cases/mod.rs index c08864b78f..12fe8b579d 100644 --- a/crates/conformance/src/cases/mod.rs +++ b/crates/conformance/src/cases/mod.rs @@ -35,6 +35,7 @@ mod runtime; mod rust_backend; mod security; mod semantic_ir; +mod stdlib; mod tooling; mod typed_diagnostics; mod verification; @@ -114,6 +115,7 @@ pub fn run(id: &str) { "RT" => runtime::run(id), "TL" => tooling::run(id), "AU" => authoring::run(id), + "SL" => stdlib::run(id), _ => panic!("no conformance case is wired for {id}"), } } diff --git a/crates/conformance/src/cases/repository.rs b/crates/conformance/src/cases/repository.rs index cdd57c7004..684b2279e7 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(), 393, "§31 has 393 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/cases/stdlib.rs b/crates/conformance/src/cases/stdlib.rs new file mode 100755 index 0000000000..ca5cdef682 --- /dev/null +++ b/crates/conformance/src/cases/stdlib.rs @@ -0,0 +1,655 @@ +//! The standard library (SPEC.md §17.22): the `stdlib/` project, whose +//! members are certified production roots, and the differential of each +//! member against the function of Rust's standard library it corresponds +//! to, under the calculus evaluator and under the pinned rustc. + +use std::collections::BTreeMap; + +use lexlean::calculus::rust::package::Passing; +use lexlean::calculus::rust::{self, Profile}; +use lexlean::calculus::{self as target, interp, Value}; +use lexlean::production::lower::{linked_modules, lower_root, roots, Lowered}; +use serde_json::Value as Json; + +use crate::production_export as harness; +use crate::rust_build::{cargo_in, workspace, Built}; +use crate::rust_harness::{self, Calls}; +use crate::rust_packages; +use crate::support::{self, P}; + +/// The module the first member lives in. +const MODULE: &str = "LexLeanStd.Text"; + +/// The members in the order the module declares them, each with the effects +/// its declaration admits, which are exactly the effects its closure +/// realizes. +const MEMBERS: [(&str, &[&str]); 7] = [ + ("startsWith", &["allocation"]), + ("endsWith", &["allocation"]), + ("trim", &["allocation", "overflow", "recursion"]), + ("splitOn", &["allocation", "overflow", "recursion"]), + ("lines", &["allocation", "overflow", "recursion"]), + ("joinWith", &["allocation", "recursion"]), + ("find", &["allocation", "overflow", "recursion"]), +]; + +/// Argument lists per member under the evaluator. +const EVALUATOR_RUNS: usize = 600; +/// Argument lists per member under rustc. +const RUSTC_RUNS: usize = 3_000; +/// The evaluator's fuel; a member that exhausts it fails the case. +const FUEL: u64 = 50_000_000; + +/// The bytes a byte-level corpus is drawn from: letters, every ASCII white +/// space byte with the vertical tab that is not one, punctuation, the +/// extremes, and the two bytes of `é`. +const BYTES: &[u8] = &[ + b'a', b'b', b'c', b' ', b'\t', b'\n', 0x0c, b'\r', 0x0b, b',', b'.', 0x00, 0xff, 0xc3, 0xa9, +]; +/// The white space a trimmed corpus is padded with. +const PADDING: &[u8] = &[b' ', b'\t', b'\n', 0x0c, b'\r', 0x0b]; +/// The pieces a UTF-8 corpus is drawn from, for the oracles over `str`. +const PIECES: &[&str] = &[ + "a", "b", "c", " ", "\n", "\r\n", "\r", "\u{e9}", "\u{65e5}", "\t", "ab", "", +]; + +/// A deterministic generator (xorshift64*), so the corpus is the same on +/// every host. +struct Seeded(u64); + +impl Seeded { + fn next(&mut self) -> u64 { + self.0 ^= self.0 >> 12; + self.0 ^= self.0 << 25; + self.0 ^= self.0 >> 27; + self.0.wrapping_mul(0x2545_F491_4F6C_DD1D) + } + fn below(&mut self, bound: usize) -> usize { + usize::try_from(self.next() % u64::try_from(bound).expect("a bound")).expect("below") + } + fn pick<'a, T>(&mut self, items: &'a [T]) -> &'a T { + &items[self.below(items.len())] + } + fn chance(&mut self, percent: usize) -> bool { + self.below(100) < percent + } + /// Up to `max` items, long on occasion. + fn count(&mut self, max: usize) -> usize { + if self.chance(5) { + self.below(4 * max + 1) + } else { + self.below(max + 1) + } + } + fn raw(&mut self, max: usize) -> Vec { + (0..self.count(max)).map(|_| *self.pick(BYTES)).collect() + } + fn text(&mut self, max: usize) -> String { + (0..self.count(max)).map(|_| *self.pick(PIECES)).collect() + } +} + +fn hex(bytes: &[u8]) -> String { + bytes.iter().map(|byte| format!("{byte:02x}")).collect() +} +fn bytes(value: &[u8]) -> Value { + Value::Bytes { hex: hex(value) } +} +fn byte(value: u8) -> Value { + Value::U8 { + value: value.to_string(), + } +} +fn boolean(value: bool) -> Value { + Value::Bool { value } +} +fn nat(value: usize) -> Value { + Value::Nat { + value: value.to_string(), + } +} +fn list(items: Vec) -> Value { + Value::List { items } +} +fn byte_list<'a>(items: impl Iterator) -> Value { + list(items.map(bytes).collect()) +} +fn option(value: Option) -> Value { + match value { + Some(value) => Value::Some { + value: Box::new(value), + }, + None => Value::None, + } +} + +/// One run: the member's arguments and the oracle's observable outcome. +type Run = (Vec, Json); + +fn record(out: &mut Vec, arguments: Vec, expected: &Value) { + out.push(( + arguments, + serde_json::to_value(expected).expect("a value is JSON"), + )); +} + +/// A prefix, suffix, or substring of `subject` at character boundaries. +fn part(seeded: &mut Seeded, subject: &str) -> String { + let boundaries: Vec = subject + .char_indices() + .map(|(index, _)| index) + .chain([subject.len()]) + .collect(); + let mut from = *seeded.pick(&boundaries); + let mut to = *seeded.pick(&boundaries); + if from > to { + std::mem::swap(&mut from, &mut to); + } + subject[from..to].to_owned() +} + +/// The corpus of one member: its edge cases, then seeded random inputs up +/// to `runs`, each with the outcome of the member's oracle in Rust's +/// standard library. +#[allow(clippy::too_many_lines)] +fn corpus(member: &str, runs: usize) -> Vec { + let mut seed = 0x9e37_79b9_7f4a_7c15_u64; + for character in member.bytes() { + seed = seed.rotate_left(8) ^ u64::from(character); + } + let mut seeded = Seeded(seed); + let mut out = Vec::new(); + match member { + "startsWith" => { + let fixed: [(&[u8], &[u8]); 7] = [ + (b"", b""), + (b"", b"a"), + (b"a", b""), + (b"abc", b"ab"), + (b"abc", b"abc"), + (b"abc", b"abcd"), + (b"abc", b"bc"), + ]; + for (subject, prefix) in fixed { + record( + &mut out, + vec![bytes(subject), bytes(prefix)], + &boolean(subject.starts_with(prefix)), + ); + } + while out.len() < runs { + let subject = seeded.raw(16); + let prefix = if seeded.chance(50) { + subject[..seeded.below(subject.len() + 1)].to_vec() + } else { + seeded.raw(4) + }; + record( + &mut out, + vec![bytes(&subject), bytes(&prefix)], + &boolean(subject.starts_with(&prefix)), + ); + } + } + "endsWith" => { + let fixed: [(&[u8], &[u8]); 7] = [ + (b"", b""), + (b"", b"a"), + (b"a", b""), + (b"abc", b"bc"), + (b"abc", b"abc"), + (b"abc", b"zabc"), + (b"abc", b"ab"), + ]; + for (subject, suffix) in fixed { + record( + &mut out, + vec![bytes(subject), bytes(suffix)], + &boolean(subject.ends_with(suffix)), + ); + } + while out.len() < runs { + let subject = seeded.raw(16); + let suffix = if seeded.chance(50) { + subject[seeded.below(subject.len() + 1)..].to_vec() + } else { + seeded.raw(4) + }; + record( + &mut out, + vec![bytes(&subject), bytes(&suffix)], + &boolean(subject.ends_with(&suffix)), + ); + } + } + "trim" => { + let fixed: [&[u8]; 8] = [ + b"", + b" ", + b" a ", + b"a", + b"\x0b a \x0b", + b"\t\n\x0c\r a\r\x0c\n\t", + b" a b ", + b"\x0b", + ]; + for subject in fixed { + record(&mut out, vec![bytes(subject)], &bytes(subject.trim_ascii())); + } + while out.len() < runs { + let mut subject: Vec = (0..seeded.below(4)) + .map(|_| *seeded.pick(PADDING)) + .collect(); + subject.extend(seeded.raw(12)); + subject.extend((0..seeded.below(4)).map(|_| *seeded.pick(PADDING))); + record( + &mut out, + vec![bytes(&subject)], + &bytes(subject.trim_ascii()), + ); + } + } + "splitOn" => { + let fixed: [(&[u8], u8); 7] = [ + (b"", b','), + (b",", b','), + (b"a,", b','), + (b",a", b','), + (b"a,b,,c", b','), + (b"abc", b','), + (b",,", b','), + ]; + for (subject, delimiter) in fixed { + record( + &mut out, + vec![bytes(subject), byte(delimiter)], + &byte_list(subject.split(|candidate| *candidate == delimiter)), + ); + } + while out.len() < runs { + let subject = seeded.raw(16); + let delimiter = if seeded.chance(80) { + *seeded.pick(BYTES) + } else { + u8::try_from(seeded.below(256)).expect("a byte") + }; + record( + &mut out, + vec![bytes(&subject), byte(delimiter)], + &byte_list(subject.split(|candidate| *candidate == delimiter)), + ); + } + } + "lines" => { + for subject in [ + "", "\n", "a", "a\n", "a\r\n", "a\r", "\r\n\r\n", "a\n\nb", "a\rb\n", "\r", + "a\r\r\n", + ] { + record( + &mut out, + vec![bytes(subject.as_bytes())], + &byte_list(subject.lines().map(str::as_bytes)), + ); + } + while out.len() < runs { + let subject = seeded.text(12); + record( + &mut out, + vec![bytes(subject.as_bytes())], + &byte_list(subject.lines().map(str::as_bytes)), + ); + } + } + "joinWith" => { + let fixed: [(&[&[u8]], &[u8]); 6] = [ + (&[], b","), + (&[b"a"], b","), + (&[b"", b""], b","), + (&[b"a", b"b"], b""), + (&[b"a", b"b"], b", "), + (&[b"", b"a", b""], b"\n"), + ]; + for (pieces, separator) in fixed { + let owned: Vec> = pieces.iter().map(|piece| piece.to_vec()).collect(); + record( + &mut out, + vec![byte_list(owned.iter().map(Vec::as_slice)), bytes(separator)], + &bytes(&owned.join(separator)), + ); + } + while out.len() < runs { + let pieces: Vec> = (0..seeded.below(6)).map(|_| seeded.raw(5)).collect(); + let separator = seeded.raw(3); + record( + &mut out, + vec![ + byte_list(pieces.iter().map(Vec::as_slice)), + bytes(&separator), + ], + &bytes(&pieces.join(&separator[..])), + ); + } + } + "find" => { + for (haystack, needle) in [ + ("", ""), + ("abc", ""), + ("", "a"), + ("abcabc", "ca"), + ("ab", "abc"), + ("aaa", "aa"), + ("\u{e9}a", "a"), + ("a\u{65e5}b", "\u{65e5}b"), + ] { + record( + &mut out, + vec![bytes(haystack.as_bytes()), bytes(needle.as_bytes())], + &option(haystack.find(needle).map(nat)), + ); + } + while out.len() < runs { + let haystack = seeded.text(12); + let needle = if seeded.chance(50) { + part(&mut seeded, &haystack) + } else { + seeded.text(2) + }; + record( + &mut out, + vec![bytes(haystack.as_bytes()), bytes(needle.as_bytes())], + &option(haystack.find(needle.as_str()).map(nat)), + ); + } + } + other => panic!("`{other}` is not a member of {MODULE}"), + } + out +} + +/// The lowered program of one member of the checked project. +fn lower(checked: &lexlean::link::CheckedProject, project: &P, member: &str) -> Lowered { + let linked = linked_modules(checked); + let roots = roots(checked).expect("the production roots"); + let root = format!("{MODULE}.{member}"); + let found = roots + .iter() + .find(|candidate| candidate.report.root == root) + .unwrap_or_else(|| panic!("`{root}` is a production root")); + lower_root( + &linked, + &found.module, + &found.name, + found.report, + &support::limits(project), + ) + .expect("the root lowers") +} + +/// Every run of `corpus` on which the evaluator and the oracle disagree. +fn evaluate(lowered: &Lowered, corpus: &[Run]) -> Vec { + corpus + .iter() + .enumerate() + .filter_map(|(run, (arguments, expected))| { + let outcome = interp::run(&lowered.program, FUEL, lowered.entry(), arguments); + let observed = rust::observable(&outcome) + .unwrap_or_else(|| panic!("run {run} on {arguments:?}: {outcome:?}")); + (&observed != expected) + .then(|| format!("run {run} on {arguments:?}: {observed} != {expected}")) + }) + .collect() +} + +fn snake(member: &str) -> String { + let mut out = String::new(); + for character in member.chars() { + if character.is_ascii_uppercase() { + out.push('_'); + out.push(character.to_ascii_lowercase()); + } else { + out.push(character); + } + } + out +} + +/// Run the case for one `SL` conformance ID. +/// +/// # Panics +/// +/// Panics when the case's assertion fails. +pub fn run(id: &str) { + match id { + // §17.22: the first member, bytes and text over `Bytes`. + "SL-01" => { + let project = P::stdlib(); + project.check_ok(); + let built = project.build_ok(); + let build_id = built.build_id.expect("built"); + let report: Json = serde_json::from_slice( + &std::fs::read( + project + .build_dir(&build_id) + .join("production/LexLeanStd/Text.eligibility.json") + .as_std_path(), + ) + .expect("the eligibility report"), + ) + .expect("the report is JSON"); + let reported = report["roots"].as_array().expect("roots"); + assert_eq!( + reported + .iter() + .map(|row| row["root"].as_str().expect("root").to_owned()) + .collect::>(), + MEMBERS + .iter() + .map(|(member, _)| format!("{MODULE}.{member}")) + .collect::>(), + "the seven members are the module's production roots, in order" + ); + for (row, (member, effects)) in reported.iter().zip(MEMBERS) { + let declared: Vec<&str> = row["declared_effects"] + .as_array() + .expect("declared effects") + .iter() + .map(|effect| effect.as_str().expect("an effect")) + .collect(); + assert_eq!(declared, effects, "{member}: the declared effects"); + let targets = row["targets"].as_array().expect("targets"); + assert_eq!(targets.len(), 1, "{member}: one target"); + let target = &targets[0]; + assert_eq!(target["target"], "rust-std", "{member}: the target"); + assert_eq!(target["status"], "eligible", "{member}: eligible"); + let realized: Vec<&str> = target["effects"] + .as_array() + .expect("effects") + .iter() + .map(|effect| effect["effect"].as_str().expect("an effect")) + .collect(); + assert_eq!( + realized, effects, + "{member}: the declaration admits exactly the realized effects" + ); + } + // Every member lowers once; the evaluator runs its corpus. + let checked = support::checked_project(&project); + let lowered: BTreeMap<&str, Lowered> = MEMBERS + .iter() + .map(|(member, _)| (*member, lower(&checked, &project, member))) + .collect(); + for (member, _) in MEMBERS { + let disagreements = evaluate(&lowered[member], &corpus(member, EVALUATOR_RUNS)); + assert!( + disagreements.is_empty(), + "{member}: the evaluator and Rust's standard library disagree on {} of {EVALUATOR_RUNS} runs: {:?}", + disagreements.len(), + &disagreements[..disagreements.len().min(5)] + ); + } + // The rendered rust-std package of every member, compiled by the + // pinned rustc, runs the larger corpus. + let dir = tempfile::Builder::new() + .prefix("lexlean-stdlib-") + .tempdir() + .expect("tempdir"); + let mut crates = Vec::new(); + let mut expected: BTreeMap> = BTreeMap::new(); + for (member, _) in MEMBERS { + let low = &lowered[member]; + let manifest = rust_packages::manifest( + &format!("text_{}", snake(member)), + &low.program, + low.entry(), + Profile::Std, + ); + let package = + target::package(&manifest.to_file_bytes().expect("canonical manifest")) + .unwrap_or_else(|failure| panic!("{member}: {failure:?}")); + let runs = corpus(member, RUSTC_RUNS); + let arguments: Vec> = runs + .iter() + .map(|(arguments, _)| arguments.clone()) + .collect(); + let arity = low.program.functions[usize::try_from(low.entry()).expect("entry")] + .types + .len(); + let passing = vec![Passing::Own; arity]; + let harness_source = rust_harness::render_calls( + &low.program, + Profile::Std, + &manifest.name, + &[Calls { + entry: low.entry(), + function: "run", + passing: &passing, + arguments: &arguments, + }], + ) + .expect("the differential harness"); + expected.insert( + manifest.name.clone(), + runs.into_iter().map(|(_, expected)| expected).collect(), + ); + crates.push(Built { + name: manifest.name, + files: package.files, + harness: harness_source, + }); + } + workspace(dir.path(), &crates); + let build = cargo_in( + dir.path(), + &["build", "--offline", "--workspace", "--quiet"], + ); + assert!( + build.status.success(), + "a member's package does not build:\n{}", + String::from_utf8_lossy(&build.stderr) + ); + for (name, outcomes) in &expected { + let binary = dir + .path() + .join("target/debug") + .join(format!("run_{name}{}", std::env::consts::EXE_SUFFIX)); + let ran = std::process::Command::new(&binary) + .output() + .expect("the differential runs"); + assert!( + ran.status.success(), + "{name}: {}", + String::from_utf8_lossy(&ran.stderr) + ); + let stdout = String::from_utf8(ran.stdout).expect("utf8"); + let printed: Vec = stdout + .lines() + .filter(|line| !line.starts_with("work ")) + .map(|line| { + serde_json::from_str(line) + .unwrap_or_else(|error| panic!("{name}: {error}: {line}")) + }) + .collect(); + assert_eq!(printed.len(), outcomes.len(), "{name}: one outcome per run"); + let disagreements: Vec = printed + .iter() + .zip(outcomes) + .enumerate() + .filter(|(_, (printed, expected))| printed != expected) + .map(|(run, (printed, expected))| format!("run {run}: {printed} != {expected}")) + .collect(); + assert!( + disagreements.is_empty(), + "{name}: the rendering and Rust's standard library disagree on {} of {} runs: {:?}", + disagreements.len(), + outcomes.len(), + &disagreements[..disagreements.len().min(5)] + ); + } + // The gate is armed: a `trim` that takes the vertical tab for + // white space and not the form feed disagrees with `trim_ascii`. + let planted = P::stdlib(); + let text = planted.read_raw("src/Text.lex.tex"); + let site = "(prim equal byte (12 : UInt8) : Bool)"; + assert!(text.contains(site), "the plant site exists"); + planted.write( + "src/Text.lex.tex", + &text.replacen(site, "(prim equal byte (11 : UInt8) : Bool)", 1), + ); + let checked = support::checked_project(&planted); + let trim = lower(&checked, &planted, "trim"); + let disagreements = evaluate(&trim, &corpus("trim", EVALUATOR_RUNS)); + assert!( + !disagreements.is_empty(), + "a planted character class in `trim` is detected by the differential" + ); + // Under the pinned Lean, the production export certifies every + // member; its packages are the committed ones and realize the + // programs the differential ran. + if !support::lean_backed("SL-01") { + return; + } + let exported = harness::exported("stdlib"); + let bundle = exported.bundle(); + let packages = harness::tree(&bundle.join("packages")); + let committed = harness::tree(&harness::fixture_dir("stdlib").join("packages")); + assert_eq!( + packages.keys().collect::>(), + committed.keys().collect::>(), + "the exported package files are the committed ones" + ); + for (relative, content) in &packages { + assert!( + committed.get(relative) == Some(content), + "packages/{relative} differs from the committed package" + ); + } + let mut realized = 0usize; + for root in &exported.output.result.roots { + let member = root + .root + .strip_prefix(&format!("{MODULE}.")) + .unwrap_or_else(|| panic!("{} is a member", root.root)); + for output in &root.outputs { + let package: Json = serde_json::from_slice( + &std::fs::read( + bundle + .join(&output.package.directory) + .join("package.json") + .as_std_path(), + ) + .expect("package.json"), + ) + .expect("package JSON"); + assert_eq!( + package["program"], + serde_json::to_value(&lowered[member].program).expect("a program is JSON"), + "{member}: the exported package realizes the program the differential ran" + ); + realized += 1; + } + } + assert_eq!(realized, MEMBERS.len(), "one certified package per member"); + } + other => panic!("no stdlib case is wired for {other}"), + } +} diff --git a/crates/conformance/src/production_export.rs b/crates/conformance/src/production_export.rs index 8b5c4005bd..ea2f98779e 100644 --- a/crates/conformance/src/production_export.rs +++ b/crates/conformance/src/production_export.rs @@ -18,6 +18,13 @@ use crate::support::{self, P}; /// The examples the consumer exports. pub const EXAMPLES: [&str; 2] = ["production", "production-coverage"]; +/// The standard library (§17.22), exported as the examples are. +pub const STDLIB: &str = "stdlib"; + +/// Every project the consumer exports: the examples and the standard +/// library, whose packages `check-production-export` compares. +pub const EXPORTED: [&str; 3] = ["production", "production-coverage", STDLIB]; + /// The root the GNAF evidence is built for, and where it is written. pub const GNAF_ROOT: &str = "Production.Main.sumAll"; /// The project-relative GNAF request path. @@ -224,7 +231,11 @@ pub fn export(example: &str) -> Result { // The export reads the environment (the toolchain, `PATH`), which a case // that sets it for a moment must not change under it. let _environment = support::env_shared(); - let project = P::copy_example(example); + let project = if example == STDLIB { + P::stdlib() + } else { + P::copy_example(example) + }; let gnaf = (example == "production").then(|| gnaf_evidence(&project)); let mut evidence = Vec::new(); if let Some(gnaf) = &gnaf { @@ -281,9 +292,11 @@ pub fn export(example: &str) -> Result { pub fn exported(example: &str) -> &'static Exported { static PRODUCTION: OnceLock = OnceLock::new(); static COVERAGE: OnceLock = OnceLock::new(); + static STANDARD: OnceLock = OnceLock::new(); let cell = match example { "production" => &PRODUCTION, "production-coverage" => &COVERAGE, + STDLIB => &STANDARD, other => panic!("`{other}` is not an exported example"), }; cell.get_or_init(|| export(example).unwrap_or_else(|reason| panic!("{reason}"))) @@ -318,7 +331,7 @@ pub fn tree(root: &Utf8Path) -> BTreeMap> { /// Every difference, or the export's failure. pub fn check(write: bool) -> Result<(), String> { let mut unmet = Vec::new(); - for example in EXAMPLES { + for example in EXPORTED { let exported = export(example)?; let packages = tree(&exported.bundle().join("packages")); let expected_root = fixture_dir(example).join("packages"); diff --git a/crates/conformance/src/support.rs b/crates/conformance/src/support.rs index 20da8b6775..6539512306 100644 --- a/crates/conformance/src/support.rs +++ b/crates/conformance/src/support.rs @@ -477,6 +477,24 @@ impl P { Self { temp, root } } + /// A fresh copy of the standard library's project (SPEC.md §17.22), + /// without build output or expected records. + #[must_use] + pub fn stdlib() -> Self { + let temp = tempfile::Builder::new() + .prefix("lexlean-stdlib-case-") + .tempdir() + .expect("tempdir"); + let source = repo_root().join("stdlib"); + assert!( + source.is_dir(), + "the committed standard library project is required" + ); + copy_tree(source.as_std_path(), temp.path(), &[".lexlean", "expected"]); + let root = Utf8PathBuf::from_path_buf(temp.path().to_path_buf()).expect("utf8 tempdir"); + Self { temp, root } + } + /// Assert that a link-time failure also refuses `build` and leaves no /// backend output (§17.12). `check` alone never runs a backend, so the /// assertion is made against the command that would: the §21.8 mutation diff --git a/crates/conformance/tests/conformance.rs b/crates/conformance/tests/conformance.rs index 0d035589fd..e383549f4c 100644 --- a/crates/conformance/tests/conformance.rs +++ b/crates/conformance/tests/conformance.rs @@ -1964,3 +1964,8 @@ fn conformance_rt_03() { fn conformance_rt_04() { repo_conformance::cases::run("RT-04"); } + +#[test] +fn conformance_sl_01() { + repo_conformance::cases::run("SL-01"); +} diff --git a/features/suites/stdlib.feature b/features/suites/stdlib.feature new file mode 100644 index 0000000000..62d784806e --- /dev/null +++ b/features/suites/stdlib.feature @@ -0,0 +1,10 @@ +Feature: stdlib + + The standard library: language-1.2 source beside the compiler, each member a certified production root validated by a seeded differential of its evaluator and rustc realizations against the Rust standard library (§17.22). + + @SL-01 @build + Scenario: The standard library's `Text` module is language-1.2 source whose seven members over `Bytes` (`startsWith`, `endsWith`, `trim`, `lines`, `splitOn`, `joinWith`, `find`) are production roots eligible for `rust-std` with exactly their declared effects; each member's lowered program under the calculus evaluator and its rendered `rust-std` package under the pinned rustc agree with Rust's `starts_with`, `ends_with`, `trim_ascii`, `lines`, `split`, `join`, and `find` on a seeded corpus; a planted defect in a member is detected; and the certified packages the production export publishes for it are the committed ones. + Given the committed `stdlib` project and the Rust standard library as the oracle + When the project is checked and built, each member is lowered and run by the evaluator and by its rendered rust-std package on a seeded corpus, a character class in `trim` is planted, and the project is exported under the pinned Lean + Then the seven roots are eligible for rust-std with exactly their declared effects and no run disagrees with the oracle + And the planted `trim` disagrees, and every exported package is byte-identical to its committed package and realizes the member's lowered program diff --git a/model/ids.toml b/model/ids.toml index 4630c0f670..12481a551e 100644 --- a/model/ids.toml +++ b/model/ids.toml @@ -2361,3 +2361,9 @@ 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 = "SL-01" +level = "build" +suite = "stdlib" +statement = "The standard library's `Text` module is language-1.2 source whose seven members over `Bytes` (`startsWith`, `endsWith`, `trim`, `lines`, `splitOn`, `joinWith`, `find`) are production roots eligible for `rust-std` with exactly their declared effects; each member's lowered program under the calculus evaluator and its rendered `rust-std` package under the pinned rustc agree with Rust's `starts_with`, `ends_with`, `trim_ascii`, `lines`, `split`, `join`, and `find` on a seeded corpus; a planted defect in a member is detected; and the certified packages the production export publishes for it are the committed ones." diff --git a/stdlib/expected/build/coverage/LexLeanStd/Text.coverage.json b/stdlib/expected/build/coverage/LexLeanStd/Text.coverage.json new file mode 100644 index 0000000000..9571a8fc85 --- /dev/null +++ b/stdlib/expected/build/coverage/LexLeanStd/Text.coverage.json @@ -0,0 +1 @@ +{"latex":[{"byte_end":134,"byte_start":0,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":715,"byte_start":134,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":1111,"byte_start":715,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":1538,"byte_start":1111,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":2027,"byte_start":1538,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":2711,"byte_start":2027,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":3524,"byte_start":2711,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":4331,"byte_start":3524,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":5009,"byte_start":4331,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":5649,"byte_start":5009,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":6222,"byte_start":5649,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":7127,"byte_start":6222,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":8201,"byte_start":7127,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":8664,"byte_start":8201,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":9559,"byte_start":8664,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":10688,"byte_start":9559,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":11642,"byte_start":10688,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":12203,"byte_start":11642,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":13261,"byte_start":12203,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":13276,"byte_start":13261,"kind":"semantic-latex-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}}],"lean":[{"byte_end":277,"byte_start":0,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":611,"byte_start":277,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":760,"byte_start":611,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":940,"byte_start":760,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":1181,"byte_start":940,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":1482,"byte_start":1181,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":1948,"byte_start":1482,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":2384,"byte_start":1948,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":2696,"byte_start":2384,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":2932,"byte_start":2696,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":3177,"byte_start":2932,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":3835,"byte_start":3177,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":4452,"byte_start":3835,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":4667,"byte_start":4452,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":5315,"byte_start":4667,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":5998,"byte_start":5315,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":6505,"byte_start":5998,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":6819,"byte_start":6505,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":7407,"byte_start":6819,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}},{"byte_end":7428,"byte_start":7407,"kind":"semantic-lean-module","origin":{"kind":"metadata","owner":"lexlean.core::semanticsource"}}],"module":"Text","source":[{"binding":{"entry":"begin","kind":"structural","package":"lexlean.core"},"byte_end":6,"byte_start":0,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":7,"byte_start":6,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"env.lexlean","kind":"structural","package":"lexlean.core"},"byte_end":14,"byte_start":7,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":15,"byte_start":14,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":16,"byte_start":15,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::env.lexlean"},"byte_end":20,"byte_start":16,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":21,"byte_start":20,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"useglossary","kind":"structural","package":"lexlean.core"},"byte_end":34,"byte_start":22,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":35,"byte_start":34,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":42,"byte_start":35,"class":"word","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":43,"byte_start":42,"class":"ascii-symbol","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":46,"byte_start":43,"class":"word","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":47,"byte_start":46,"class":"ascii-symbol","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":50,"byte_start":47,"class":"word","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":51,"byte_start":50,"class":"ascii-symbol","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":52,"byte_start":51,"class":"numeral","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":53,"byte_start":52,"class":"ascii-symbol","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":54,"byte_start":53,"class":"numeral","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":55,"byte_start":54,"class":"ascii-symbol","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::useglossary"},"byte_end":56,"byte_start":55,"class":"numeral","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":57,"byte_start":56,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"title","kind":"structural","package":"lexlean.core"},"byte_end":64,"byte_start":58,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":65,"byte_start":64,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"nat","form":"natural-number-sc","kind":"form","package":"lexlean.std.nat"},"byte_end":79,"byte_start":65,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"addition","form":"addition","kind":"form","package":"lexlean.std.nat"},"byte_end":88,"byte_start":80,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":89,"byte_start":88,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"begin","kind":"structural","package":"lexlean.core"},"byte_end":96,"byte_start":90,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":97,"byte_start":96,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"env.semanticmodule","kind":"structural","package":"lexlean.core"},"byte_end":111,"byte_start":97,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":112,"byte_start":111,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"kind":"metadata","owner":"lexlean.core::semanticsource"},"byte_end":8046,"byte_start":113,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"end","kind":"structural","package":"lexlean.core"},"byte_end":8050,"byte_start":8046,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":8051,"byte_start":8050,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"env.semanticmodule","kind":"structural","package":"lexlean.core"},"byte_end":8065,"byte_start":8051,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":8066,"byte_start":8065,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"end","kind":"structural","package":"lexlean.core"},"byte_end":8071,"byte_start":8067,"class":"control","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-open","kind":"structural","package":"lexlean.core"},"byte_end":8072,"byte_start":8071,"class":"delimiter","path":"src/Text.lex.tex"},{"binding":{"entry":"env.lexlean","kind":"structural","package":"lexlean.core"},"byte_end":8079,"byte_start":8072,"class":"word","path":"src/Text.lex.tex"},{"binding":{"entry":"brace-close","kind":"structural","package":"lexlean.core"},"byte_end":8080,"byte_start":8079,"class":"delimiter","path":"src/Text.lex.tex"}],"spec":"lexlean/coverage/1"} diff --git a/stdlib/expected/build/lexicons/Text.closure.json b/stdlib/expected/build/lexicons/Text.closure.json new file mode 100644 index 0000000000..6c7af39f12 --- /dev/null +++ b/stdlib/expected/build/lexicons/Text.closure.json @@ -0,0 +1 @@ +{"module":"Text","packages":[{"entries":[{"category":"grammar","id":"a"},{"category":"structural","id":"allowaxioms"},{"category":"grammar","id":"alternative"},{"category":"grammar","id":"an"},{"category":"grammar","id":"and"},{"category":"proof-constant","id":"and-intro","signature_sha256":"3ae5651d6fc8a15bcaba9d07d64ab88cbbabfd966e66953e27a652c892b5b490"},{"category":"grammar","id":"apply-verb"},{"category":"infix-function","id":"arrow","signature_sha256":"4ab8273d45e3bda75d484468dd51cd1f4614a5d9b73a6fc066388aa72636a717"},{"category":"grammar","id":"as"},{"category":"grammar","id":"assume"},{"category":"structural","id":"at"},{"category":"structural","id":"backward"},{"category":"structural","id":"begin"},{"category":"structural","id":"bind"},{"category":"structural","id":"brace-close"},{"category":"structural","id":"brace-open"},{"category":"structural","id":"bracket-close"},{"category":"structural","id":"bracket-open"},{"category":"label-word","id":"branch-word"},{"category":"grammar","id":"by"},{"category":"label-word","id":"case-word"},{"category":"grammar","id":"cases-noun"},{"category":"grammar","id":"close"},{"category":"structural","id":"colon"},{"category":"structural","id":"comma"},{"category":"grammar","id":"consider"},{"category":"grammar","id":"defined"},{"category":"structural","id":"display-close"},{"category":"structural","id":"display-open"},{"category":"structural","id":"end"},{"category":"structural","id":"env.apply"},{"category":"structural","id":"env.branch"},{"category":"structural","id":"env.calculate"},{"category":"structural","id":"env.case"},{"category":"structural","id":"env.cases"},{"category":"structural","id":"env.constructor"},{"category":"structural","id":"env.corollary"},{"category":"structural","id":"env.have"},{"category":"structural","id":"env.induction"},{"category":"structural","id":"env.lemma"},{"category":"structural","id":"env.lexlean"},{"category":"structural","id":"env.predicatedefinition"},{"category":"structural","id":"env.premise"},{"category":"structural","id":"env.proof"},{"category":"structural","id":"env.rewrite"},{"category":"structural","id":"env.section"},{"category":"structural","id":"env.simplify"},{"category":"structural","id":"env.termdefinition"},{"category":"structural","id":"env.theorem"},{"category":"structural","id":"env.typedefinition"},{"category":"infix-predicate","id":"eq","signature_sha256":"fff6703047a5db5ce2f1084729d26de7c98b060880f10d11bf993e61583a417a"},{"category":"grammar","id":"establish"},{"category":"grammar","id":"every"},{"category":"structural","id":"exactaxioms"},{"category":"grammar","id":"exactly"},{"category":"grammar","id":"exists"},{"category":"proof-constant","id":"exists-intro","signature_sha256":"826877f0c5dacbef193c11d1e3e4338883dd1db68a5ec9d73640e4fa6ab856f9"},{"category":"function","id":"exists-op","signature_sha256":"6fe6ba416d461756b942d1a826db5ba62ecb89ad10c83e5429fda5676ef1987b"},{"category":"grammar","id":"first"},{"category":"grammar","id":"follows"},{"category":"grammar","id":"for"},{"category":"structural","id":"forward"},{"category":"grammar","id":"from"},{"category":"grammar","id":"goal"},{"category":"structural","id":"heading"},{"category":"grammar","id":"holds"},{"category":"structural","id":"hyphen"},{"category":"grammar","id":"if"},{"category":"infix-function","id":"iff","signature_sha256":"4ab8273d45e3bda75d484468dd51cd1f4614a5d9b73a6fc066388aa72636a717"},{"category":"proof-constant","id":"iff-intro","signature_sha256":"916fefdef3740a5a417db539a07f7c64c80b167b4b56376e04ae5a34ef2a24d3"},{"category":"grammar","id":"implies"},{"category":"structural","id":"importmodule"},{"category":"grammar","id":"induction-noun"},{"category":"grammar","id":"is"},{"category":"infix-function","id":"land","signature_sha256":"4ab8273d45e3bda75d484468dd51cd1f4614a5d9b73a6fc066388aa72636a717"},{"category":"grammar","id":"left"},{"category":"structural","id":"lexeme"},{"category":"prefix-function","id":"lnot","signature_sha256":"b58227252ab1afe7522f2d168e1d8bb96947273b77d8d69d9d5d62a5616e45f7"},{"category":"infix-function","id":"lor","signature_sha256":"4ab8273d45e3bda75d484468dd51cd1f4614a5d9b73a6fc066388aa72636a717"},{"category":"structural","id":"math-close"},{"category":"structural","id":"math-open"},{"category":"structural","id":"noaxioms"},{"category":"grammar","id":"not"},{"category":"grammar","id":"of"},{"category":"grammar","id":"on"},{"category":"grammar","id":"one"},{"category":"grammar","id":"only"},{"category":"grammar","id":"or"},{"category":"proof-constant","id":"or-inl","signature_sha256":"15bc04b85dd3fa7919a5346eb884241553989ba798adf2a7d070b80d77d6d46a"},{"category":"proof-constant","id":"or-inr","signature_sha256":"8e845723a60966714d93537e9cf60ab49f228514f7c617e0f66e119b3a642a2c"},{"category":"structural","id":"parameters"},{"category":"label-word","id":"parameters-concept"},{"category":"structural","id":"paren-close"},{"category":"structural","id":"paren-open"},{"category":"structural","id":"period"},{"category":"label-word","id":"premise-word"},{"category":"grammar","id":"proceed"},{"category":"structural","id":"reference"},{"category":"grammar","id":"reflexivity"},{"category":"grammar","id":"rewrite-verb"},{"category":"grammar","id":"right"},{"category":"structural","id":"rule"},{"category":"grammar","id":"select"},{"category":"structural","id":"semicolon"},{"category":"grammar","id":"simplify-verb"},{"category":"structural","id":"start"},{"category":"structural","id":"step"},{"category":"grammar","id":"such"},{"category":"grammar","id":"that"},{"category":"grammar","id":"the"},{"category":"grammar","id":"then"},{"category":"grammar","id":"there"},{"category":"structural","id":"title"},{"category":"grammar","id":"use"},{"category":"structural","id":"useglossary"},{"category":"grammar","id":"using"},{"category":"grammar","id":"we"},{"category":"grammar","id":"when"},{"category":"grammar","id":"with"},{"category":"grammar","id":"witness"}],"id":"lexlean.core","manifest_sha256":"271079763d269cc873531f515e56da960cd6321393b9460ff0e617666fa01d71","tree_sha256":"827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392","version":"1.2.0"},{"entries":[{"category":"infix-function","id":"and","signature_sha256":"2b8099618ae87bc9783ad11c4542074cbdadb46de8d6f45bd6cf0ecbb4a09f1e"},{"category":"type-noun","id":"bool","signature_sha256":"f23ac5c59894fab109f943cb71f3f118d39c2a11dd566054b9cca7baeb70e9d1"},{"category":"term-constant","id":"false","signature_sha256":"3c702a2431352e1a42f2d4a0768bb00667c5ed6ee32a89b9d4e6b17aa7505c26"},{"category":"function","id":"not","signature_sha256":"8f0bb0dac6dd181c978e426d07cff3f2c69d76d9d8af90c55b979363fe8ee167"},{"category":"infix-function","id":"or","signature_sha256":"2b8099618ae87bc9783ad11c4542074cbdadb46de8d6f45bd6cf0ecbb4a09f1e"},{"category":"term-constant","id":"true","signature_sha256":"3c702a2431352e1a42f2d4a0768bb00667c5ed6ee32a89b9d4e6b17aa7505c26"}],"id":"lexlean.std.bool","manifest_sha256":"de58de2cf18a7a5a62d8c20649139d6dfe1f7b16b3130c75f150fbac5440a71e","tree_sha256":"3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b","version":"1.2.0"},{"entries":[{"category":"infix-function","id":"add","signature_sha256":"c40b9c6487d0986522dc6b35add4d048dd3a256337e8be35254f09430dd42356"},{"category":"label-word","id":"addition"},{"category":"infix-function","id":"beq","signature_sha256":"e0ba0da404022f58ba89c723ed7b4f9187b43f1b8a74228c54812ef073d56019"},{"category":"function","id":"ble","signature_sha256":"e0ba0da404022f58ba89c723ed7b4f9187b43f1b8a74228c54812ef073d56019"},{"category":"function","id":"blt","signature_sha256":"e0ba0da404022f58ba89c723ed7b4f9187b43f1b8a74228c54812ef073d56019"},{"category":"infix-function","id":"div","signature_sha256":"c40b9c6487d0986522dc6b35add4d048dd3a256337e8be35254f09430dd42356"},{"category":"infix-predicate","id":"ge","signature_sha256":"2ec88c5373669b45b27824b507815b6af546db4921cb05ded0757c5131444d81"},{"category":"infix-predicate","id":"gt","signature_sha256":"2ec88c5373669b45b27824b507815b6af546db4921cb05ded0757c5131444d81"},{"category":"infix-function","id":"inter","signature_sha256":"855f18d5a8192acd8a13ebf416d8d1946395a7108a359d562caac2c8b5a75801"},{"category":"infix-predicate","id":"le","signature_sha256":"2ec88c5373669b45b27824b507815b6af546db4921cb05ded0757c5131444d81"},{"category":"function","id":"list","signature_sha256":"6d6685ec3b3b8a12cc96b0559d1216b9dd77084b1a12e4776cb6b9366692af7f"},{"category":"infix-predicate","id":"lt","signature_sha256":"2ec88c5373669b45b27824b507815b6af546db4921cb05ded0757c5131444d81"},{"category":"infix-predicate","id":"mem","signature_sha256":"be248583768890865a7b2550ac757599105728a5a475dc218badd0cfb8dfc2b1"},{"category":"infix-function","id":"mul","signature_sha256":"c40b9c6487d0986522dc6b35add4d048dd3a256337e8be35254f09430dd42356"},{"category":"type-noun","id":"nat","signature_sha256":"f23ac5c59894fab109f943cb71f3f118d39c2a11dd566054b9cca7baeb70e9d1"},{"category":"type-noun","id":"nat-list","signature_sha256":"f23ac5c59894fab109f943cb71f3f118d39c2a11dd566054b9cca7baeb70e9d1"},{"category":"infix-predicate","id":"ne","signature_sha256":"2ec88c5373669b45b27824b507815b6af546db4921cb05ded0757c5131444d81"},{"category":"infix-predicate","id":"not-mem","signature_sha256":"be248583768890865a7b2550ac757599105728a5a475dc218badd0cfb8dfc2b1"},{"category":"infix-function","id":"prod","signature_sha256":"dcce60e7e417656677465e47c16f959b4af4cf1c379e434dad71e273798b9545"},{"category":"function","id":"remove-all","signature_sha256":"855f18d5a8192acd8a13ebf416d8d1946395a7108a359d562caac2c8b5a75801"},{"category":"infix-predicate","id":"ssubset","signature_sha256":"a3e9b3981fcd508cdc862d7bc2c2d3cbf9b8300cbc7c738018cff08ce9650025"},{"category":"infix-function","id":"sub","signature_sha256":"c40b9c6487d0986522dc6b35add4d048dd3a256337e8be35254f09430dd42356"},{"category":"infix-predicate","id":"subseteq","signature_sha256":"a3e9b3981fcd508cdc862d7bc2c2d3cbf9b8300cbc7c738018cff08ce9650025"},{"category":"function","id":"succ","signature_sha256":"28caae3ed404512c7b3d7b9304cdc6ddbf343f145ee905306d659582871abcac"},{"category":"infix-function","id":"union","signature_sha256":"855f18d5a8192acd8a13ebf416d8d1946395a7108a359d562caac2c8b5a75801"},{"category":"term-constant","id":"zero","signature_sha256":"a1eb0e00322cdc8282a96aff213a04133d617badd2f27b57cc87183777775e36"}],"id":"lexlean.std.nat","manifest_sha256":"6fb446b39e3c1c18a5f10cfa1f7aa2bd431837719eb0eb7489aadf452c9420a7","tree_sha256":"e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac","version":"1.2.0"}],"spec":"lexlean/lexicon-closure/1"} diff --git a/stdlib/expected/build/manifest.json b/stdlib/expected/build/manifest.json new file mode 100644 index 0000000000..33ff4022b3 --- /dev/null +++ b/stdlib/expected/build/manifest.json @@ -0,0 +1 @@ +{"build_id":"cfb33fd596fb061aee2203ea40e24d127301811b19ed16de4672dda8ab07aa2d","compiler":{"semantics_id":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","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":"6489f78534638166b507479ae577eabacd4fe570e8e80b420d611436a901830e"},{"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":"4e7ac926c0bd46f4762a086601672f1bd17a26f513aaa77bd7bc1eb8ee90c8cc"},{"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":"b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3","source_id":"96851ee4dba63f9f18a7a6091ca3f216c3d4e4102d6c4ec05a5eba9930c88527","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 new file mode 100644 index 0000000000..544db2bde7 --- /dev/null +++ b/stdlib/expected/build/maps/LexLeanStd/Text.map.json @@ -0,0 +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":"b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3","source_id":"96851ee4dba63f9f18a7a6091ca3f216c3d4e4102d6c4ec05a5eba9930c88527","sources":[{"id":0,"kind":"file","path":"src/Text.lex.tex","sha256":"57c487328b200f710abcf7ca1e0daf1086d31c32f668fba6e7f5dc1a2e4a1eca"}],"spec":"lexlean/source-map/1"} diff --git a/stdlib/expected/build/modules/LexLeanStd/Text.lean b/stdlib/expected/build/modules/LexLeanStd/Text.lean new file mode 100644 index 0000000000..6f547635fa --- /dev/null +++ b/stdlib/expected/build/modules/LexLeanStd/Text.lean @@ -0,0 +1,47 @@ +module +public import Init +public import LexLeanRuntime.Portable +public import LexLeanRuntime.Collections +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 1000000000 +set_option linter.constructorNameAsVariable false +namespace LexLeanStd.Text + +@[expose] public def isSpace (byte : UInt8) : Bool := ((((LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) || (LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool)) || ((LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) || (LexLeanRuntime.equal (byte) ((13 : UInt8)) : Bool))) + +@[expose] public def byteAt (subject : ByteArray) (position : Nat) : Option (UInt8) := (LexLeanRuntime.index (subject) (position) : Option (UInt8)) + +@[expose] public def spaceAt (subject : ByteArray) (position : Nat) : Bool := (match byteAt (subject) (position) with | Option.some byte => isSpace (byte) | Option.none => false) + +@[expose] public def sliceOr (subject : ByteArray) (start : Nat) (count : Nat) : ByteArray := (match (LexLeanRuntime.slice (subject) (start) (count) : Option (ByteArray)) with | Option.some piece => piece | Option.none => ByteArray.mk #[]) + +@[expose] public def startsWith (subject : ByteArray) («prefix» : ByteArray) : Bool := (match (LexLeanRuntime.slice (subject) (0) ((LexLeanRuntime.length («prefix») : Nat)) : Option (ByteArray)) with | Option.some head => (LexLeanRuntime.equal (head) («prefix») : Bool) | Option.none => false) + +@[expose] public def endsWith (subject : ByteArray) (suffix : ByteArray) : Bool := (let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let size : Nat := (LexLeanRuntime.length (suffix) : Nat); (if (Nat.ble (size) (total)) then (match (LexLeanRuntime.slice (subject) ((LexLeanRuntime.subtract (total) (size) : Nat)) (size) : Option (ByteArray)) with | Option.some tail => (LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => false) else false))) + +@[expose] public def trimEnd (subject : ByteArray) : Nat := ((LexLeanCollections.iterateUntil ((fun («end» : Nat) => (if (Nat.blt (0) («end»)) then (if spaceAt (subject) ((LexLeanRuntime.subtract («end») (1) : Nat)) then Option.some ((LexLeanRuntime.subtract («end») (1) : Nat)) else Option.none) else Option.none))) ((LexLeanRuntime.length (subject) : Nat)) ((LexLeanRuntime.length (subject) : Nat)) : (Prod (Nat) (Bool)))).1 + +@[expose] public def trimStart (subject : ByteArray) («end» : Nat) : Nat := ((LexLeanCollections.iterateUntil ((fun (start : Nat) => (if (Nat.blt (start) («end»)) then (if spaceAt (subject) (start) then Option.some ((start + 1)) else Option.none) else Option.none))) («end») (0) : (Prod (Nat) (Bool)))).1 + +@[expose] public def trim (subject : ByteArray) : ByteArray := (let «end» : Nat := trimEnd (subject); (let start : Nat := trimStart (subject) («end»); sliceOr (subject) (start) ((LexLeanRuntime.subtract («end») (start) : Nat)))) + +@[expose] public def reverse (pieces : List (ByteArray)) : List (ByteArray) := (LexLeanCollections.listFold ((fun (reversed : List (ByteArray)) (piece : ByteArray) => (piece :: reversed))) (([] : List (ByteArray))) (pieces) : List (ByteArray)) + +@[expose] public def splitStep (subject : ByteArray) (delimiter : UInt8) (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) : Option ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) := (let position : Nat := (state).1; (let start : Nat := ((state).2).1; (let pieces : List (ByteArray) := ((state).2).2; (match byteAt (subject) (position) with | Option.some byte => (if (LexLeanRuntime.equal (byte) (delimiter) : Bool) then Option.some (((position + 1), ((position + 1), (sliceOr (subject) (start) ((LexLeanRuntime.subtract (position) (start) : Nat)) :: pieces)))) else Option.some (((position + 1), (start, pieces)))) | Option.none => Option.none)))) + +@[expose] public def splitOn (subject : ByteArray) (delimiter : UInt8) : List (ByteArray) := (let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let final : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))) := ((LexLeanCollections.iterateUntil ((fun (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) => splitStep (subject) (delimiter) (state))) (total) ((0, (0, ([] : List (ByteArray))))) : (Prod ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) (Bool)))).1; (let start : Nat := ((final).2).1; reverse ((sliceOr (subject) (start) ((LexLeanRuntime.subtract (total) (start) : Nat)) :: ((final).2).2))))) + +@[expose] public def chomp (line : ByteArray) : ByteArray := (if endsWith (line) (ByteArray.mk #[13]) then sliceOr (line) (0) ((LexLeanRuntime.subtract ((LexLeanRuntime.length (line) : Nat)) (1) : Nat)) else line) + +@[expose] public def lineStep (subject : ByteArray) (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) : Option ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) := (let position : Nat := (state).1; (let start : Nat := ((state).2).1; (let pieces : List (ByteArray) := ((state).2).2; (match byteAt (subject) (position) with | Option.some byte => (if (LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) then Option.some (((position + 1), ((position + 1), (chomp (sliceOr (subject) (start) ((LexLeanRuntime.subtract (position) (start) : Nat))) :: pieces)))) else Option.some (((position + 1), (start, pieces)))) | Option.none => Option.none)))) + +@[expose] public def lines (subject : ByteArray) : List (ByteArray) := (let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let final : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))) := ((LexLeanCollections.iterateUntil ((fun (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) => lineStep (subject) (state))) (total) ((0, (0, ([] : List (ByteArray))))) : (Prod ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) (Bool)))).1; (let start : Nat := ((final).2).1; (let pieces : List (ByteArray) := ((final).2).2; (if (Nat.blt (start) (total)) then reverse ((sliceOr (subject) (start) ((LexLeanRuntime.subtract (total) (start) : Nat)) :: pieces)) else reverse (pieces)))))) + +@[expose] public def joinWith (pieces : List (ByteArray)) (separator : ByteArray) : ByteArray := (match (LexLeanCollections.listFold ((fun (joined : Option (ByteArray)) (piece : ByteArray) => (match joined with | Option.none => Option.some (piece) | Option.some sofar => Option.some ((LexLeanRuntime.append ((LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray))))) (Option.none) (pieces) : Option (ByteArray)) with | Option.some joined => joined | Option.none => ByteArray.mk #[]) + +@[expose] public def matchAt (subject : ByteArray) (needle : ByteArray) (position : Nat) : Bool := (match (LexLeanRuntime.slice (subject) (position) ((LexLeanRuntime.length (needle) : Nat)) : Option (ByteArray)) with | Option.some window => (LexLeanRuntime.equal (window) (needle) : Bool) | Option.none => false) + +@[expose] public def find (subject : ByteArray) (needle : ByteArray) : Option (Nat) := (let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let size : Nat := (LexLeanRuntime.length (needle) : Nat); (let position : Nat := ((LexLeanCollections.iterateUntil ((fun (position : Nat) => (if matchAt (subject) (needle) (position) then Option.none else (if (Nat.blt ((position + size)) (total)) then Option.some ((position + 1)) else Option.none)))) ((total + 1)) (0) : (Prod (Nat) (Bool)))).1; (if matchAt (subject) (needle) (position) then Option.some (position) else Option.none)))) + +end LexLeanStd.Text diff --git a/stdlib/expected/build/modules/LexLeanStd/Text.tex b/stdlib/expected/build/modules/LexLeanStd/Text.tex new file mode 100644 index 0000000000..df13dee8c0 --- /dev/null +++ b/stdlib/expected/build/modules/LexLeanStd/Text.tex @@ -0,0 +1,146 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage{amsmath,amssymb} +\begin{document} +\section*{Semantic declarations} +\subsection*{\texttt{isSpace}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(byte : UInt8)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Bool}.\par +\noindent Definition: \texttt{((((LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) || (LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool)) || ((LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) || (LexLeanRuntime.equal (byte) ((13 : UInt8)) : Bool)))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{byteAt}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (position : Nat)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Option (UInt8)}.\par +\noindent Definition: \texttt{(LexLeanRuntime.index (subject) (position) : Option (UInt8))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{spaceAt}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (position : Nat)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Bool}.\par +\noindent Definition: \texttt{(match byteAt (subject) (position) with | Option.some byte => isSpace (byte) | Option.none => false)}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{sliceOr}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (start : Nat) (count : Nat)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{ByteArray}.\par +\noindent Definition: \texttt{(match (LexLeanRuntime.slice (subject) (start) (count) : Option (ByteArray)) with | Option.some piece => piece | Option.none => ByteArray.mk \#[])}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{startsWith}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (prefix : ByteArray)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation}.\par +\noindent Type: \texttt{Bool}.\par +\noindent Definition: \texttt{(match (LexLeanRuntime.slice (subject) (0) ((LexLeanRuntime.length (prefix) : Nat)) : Option (ByteArray)) with | Option.some head => (LexLeanRuntime.equal (head) (prefix) : Bool) | Option.none => false)}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{endsWith}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (suffix : ByteArray)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation}.\par +\noindent Type: \texttt{Bool}.\par +\noindent Definition: \texttt{(let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let size : Nat := (LexLeanRuntime.length (suffix) : Nat); (if (Nat.ble (size) (total)) then (match (LexLeanRuntime.slice (subject) ((LexLeanRuntime.subtract (total) (size) : Nat)) (size) : Option (ByteArray)) with | Option.some tail => (LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => false) else false)))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{trimEnd}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray)}.\par +\noindent Closure 1: binds \texttt{(end)}, captures \texttt{(subject)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Nat}.\par +\noindent Definition: \texttt{((LexLeanCollections.iterateUntil ((fun (end : Nat) => (if (Nat.blt (0) (end)) then (if spaceAt (subject) ((LexLeanRuntime.subtract (end) (1) : Nat)) then Option.some ((LexLeanRuntime.subtract (end) (1) : Nat)) else Option.none) else Option.none))) ((LexLeanRuntime.length (subject) : Nat)) ((LexLeanRuntime.length (subject) : Nat)) : (Prod (Nat) (Bool)))).1}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{trimStart}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (end : Nat)}.\par +\noindent Closure 1: binds \texttt{(start)}, captures \texttt{(end, subject)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Nat}.\par +\noindent Definition: \texttt{((LexLeanCollections.iterateUntil ((fun (start : Nat) => (if (Nat.blt (start) (end)) then (if spaceAt (subject) (start) then Option.some ((start + 1)) else Option.none) else Option.none))) (end) (0) : (Prod (Nat) (Bool)))).1}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{trim}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation, overflow, recursion}.\par +\noindent Type: \texttt{ByteArray}.\par +\noindent Definition: \texttt{(let end : Nat := trimEnd (subject); (let start : Nat := trimStart (subject) (end); sliceOr (subject) (start) ((LexLeanRuntime.subtract (end) (start) : Nat))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{reverse}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(pieces : List (ByteArray))}.\par +\noindent Closure 1: binds \texttt{(reversed, piece)}, captures \texttt{()}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{List (ByteArray)}.\par +\noindent Definition: \texttt{(LexLeanCollections.listFold ((fun (reversed : List (ByteArray)) (piece : ByteArray) => (piece :: reversed))) (([] : List (ByteArray))) (pieces) : List (ByteArray))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{splitStep}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (delimiter : UInt8) (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))))}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Option ((Prod (Nat) ((Prod (Nat) (List (ByteArray))))))}.\par +\noindent Definition: \texttt{(let position : Nat := (state).1; (let start : Nat := ((state).2).1; (let pieces : List (ByteArray) := ((state).2).2; (match byteAt (subject) (position) with | Option.some byte => (if (LexLeanRuntime.equal (byte) (delimiter) : Bool) then Option.some (((position + 1), ((position + 1), (sliceOr (subject) (start) ((LexLeanRuntime.subtract (position) (start) : Nat)) :: pieces)))) else Option.some (((position + 1), (start, pieces)))) | Option.none => Option.none))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{splitOn}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (delimiter : UInt8)}.\par +\noindent Closure 1: binds \texttt{(state)}, captures \texttt{(delimiter, subject)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation, overflow, recursion}.\par +\noindent Type: \texttt{List (ByteArray)}.\par +\noindent Definition: \texttt{(let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let final : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))) := ((LexLeanCollections.iterateUntil ((fun (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) => splitStep (subject) (delimiter) (state))) (total) ((0, (0, ([] : List (ByteArray))))) : (Prod ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) (Bool)))).1; (let start : Nat := ((final).2).1; reverse ((sliceOr (subject) (start) ((LexLeanRuntime.subtract (total) (start) : Nat)) :: ((final).2).2)))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{chomp}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(line : ByteArray)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{ByteArray}.\par +\noindent Definition: \texttt{(if endsWith (line) (ByteArray.mk \#[13]) then sliceOr (line) (0) ((LexLeanRuntime.subtract ((LexLeanRuntime.length (line) : Nat)) (1) : Nat)) else line)}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{lineStep}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))))}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Option ((Prod (Nat) ((Prod (Nat) (List (ByteArray))))))}.\par +\noindent Definition: \texttt{(let position : Nat := (state).1; (let start : Nat := ((state).2).1; (let pieces : List (ByteArray) := ((state).2).2; (match byteAt (subject) (position) with | Option.some byte => (if (LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) then Option.some (((position + 1), ((position + 1), (chomp (sliceOr (subject) (start) ((LexLeanRuntime.subtract (position) (start) : Nat))) :: pieces)))) else Option.some (((position + 1), (start, pieces)))) | Option.none => Option.none))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{lines}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray)}.\par +\noindent Closure 1: binds \texttt{(state)}, captures \texttt{(subject)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation, overflow, recursion}.\par +\noindent Type: \texttt{List (ByteArray)}.\par +\noindent Definition: \texttt{(let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let final : (Prod (Nat) ((Prod (Nat) (List (ByteArray))))) := ((LexLeanCollections.iterateUntil ((fun (state : (Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) => lineStep (subject) (state))) (total) ((0, (0, ([] : List (ByteArray))))) : (Prod ((Prod (Nat) ((Prod (Nat) (List (ByteArray)))))) (Bool)))).1; (let start : Nat := ((final).2).1; (let pieces : List (ByteArray) := ((final).2).2; (if (Nat.blt (start) (total)) then reverse ((sliceOr (subject) (start) ((LexLeanRuntime.subtract (total) (start) : Nat)) :: pieces)) else reverse (pieces))))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{joinWith}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(pieces : List (ByteArray)) (separator : ByteArray)}.\par +\noindent Closure 1: binds \texttt{(joined, piece)}, captures \texttt{(separator)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation, recursion}.\par +\noindent Type: \texttt{ByteArray}.\par +\noindent Definition: \texttt{(match (LexLeanCollections.listFold ((fun (joined : Option (ByteArray)) (piece : ByteArray) => (match joined with | Option.none => Option.some (piece) | Option.some sofar => Option.some ((LexLeanRuntime.append ((LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray))))) (Option.none) (pieces) : Option (ByteArray)) with | Option.some joined => joined | Option.none => ByteArray.mk \#[])}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{matchAt}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (needle : ByteArray) (position : Nat)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Type: \texttt{Bool}.\par +\noindent Definition: \texttt{(match (LexLeanRuntime.slice (subject) (position) ((LexLeanRuntime.length (needle) : Nat)) : Option (ByteArray)) with | Option.some window => (LexLeanRuntime.equal (window) (needle) : Bool) | Option.none => false)}.\par +\noindent Axiom policy: \texttt{none}.\par +\subsection*{\texttt{find}} +\noindent Kind: \texttt{definition}.\par +\noindent Parameters: \texttt{(subject : ByteArray) (needle : ByteArray)}.\par +\noindent Closure 1: binds \texttt{(position)}, captures \texttt{(needle, size, subject, total)}.\par +\noindent Execution: executable, non-escaping closures only.\par +\noindent Production root for targets \texttt{rust-std}; admitted effects: \texttt{allocation, overflow, recursion}.\par +\noindent Type: \texttt{Option (Nat)}.\par +\noindent Definition: \texttt{(let total : Nat := (LexLeanRuntime.length (subject) : Nat); (let size : Nat := (LexLeanRuntime.length (needle) : Nat); (let position : Nat := ((LexLeanCollections.iterateUntil ((fun (position : Nat) => (if matchAt (subject) (needle) (position) then Option.none else (if (Nat.blt ((position + size)) (total)) then Option.some ((position + 1)) else Option.none)))) ((total + 1)) (0) : (Prod (Nat) (Bool)))).1; (if matchAt (subject) (needle) (position) then Option.some (position) else Option.none))))}.\par +\noindent Axiom policy: \texttt{none}.\par +\end{document} diff --git a/stdlib/expected/build/production/LexLeanStd/Text.eligibility.json b/stdlib/expected/build/production/LexLeanStd/Text.eligibility.json new file mode 100644 index 0000000000..7c50e1ad43 --- /dev/null +++ b/stdlib/expected/build/production/LexLeanStd/Text.eligibility.json @@ -0,0 +1 @@ +{"module":"Text","roots":[{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"term.bool","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"term.nat","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.startsWith"]}],"declared_effects":["allocation"],"erased":[],"root":"LexLeanStd.Text.startsWith","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.startsWith","instance":"LexLeanStd.Text.startsWith","path":["LexLeanStd.Text.startsWith"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.startsWith"},{"construct":"type.bytes","instance":"LexLeanStd.Text.startsWith"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"primitive.subtract","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.ble","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.bool","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.if","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.let","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]}],"declared_effects":["allocation"],"erased":[],"root":"LexLeanStd.Text.endsWith","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.endsWith","instance":"LexLeanStd.Text.endsWith","path":["LexLeanStd.Text.endsWith"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.endsWith"},{"construct":"type.bytes","instance":"LexLeanStd.Text.endsWith"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.isSpace","LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.isSpace"]},{"construct":"primitive.index","disposition":"runtime","instances":["LexLeanStd.Text.byteAt"]},{"construct":"primitive.iterate_until","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr"]},{"construct":"primitive.subtract","disposition":"runtime","instances":["LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd"]},{"construct":"term.add","disposition":"runtime","instances":["LexLeanStd.Text.trimStart"]},{"construct":"term.blt","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.bool","disposition":"runtime","instances":["LexLeanStd.Text.spaceAt"]},{"construct":"term.bytes","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr"]},{"construct":"term.call","disposition":"runtime","instances":["LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.constructor","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.first","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.if","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.integer","disposition":"runtime","instances":["LexLeanStd.Text.isSpace"]},{"construct":"term.lambda","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.let","disposition":"runtime","instances":["LexLeanStd.Text.trim"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt"]},{"construct":"term.nat","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.or","disposition":"runtime","instances":["LexLeanStd.Text.isSpace"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.isSpace","LexLeanStd.Text.sliceOr","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.isSpace","LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.isSpace","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.sliceOr","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.product","disposition":"runtime","instances":["LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"]},{"construct":"type.uint8","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.isSpace"]}],"declared_effects":["allocation","overflow","recursion"],"erased":[],"root":"LexLeanStd.Text.trim","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.trim","instance":"LexLeanStd.Text.trim","path":["LexLeanStd.Text.trim"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.trimEnd","instance":"LexLeanStd.Text.trimEnd","path":["LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.trimStart","instance":"LexLeanStd.Text.trimStart","path":["LexLeanStd.Text.trim","LexLeanStd.Text.trimStart"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","path":["LexLeanStd.Text.trim","LexLeanStd.Text.sliceOr"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.spaceAt","instance":"LexLeanStd.Text.spaceAt","path":["LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.spaceAt"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","path":["LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.spaceAt","LexLeanStd.Text.byteAt"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.isSpace","instance":"LexLeanStd.Text.isSpace","path":["LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.spaceAt","LexLeanStd.Text.isSpace"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.sliceOr"},{"construct":"term.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"type.bytes","instance":"LexLeanStd.Text.byteAt"},{"construct":"type.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"type.bytes","instance":"LexLeanStd.Text.spaceAt"},{"construct":"type.bytes","instance":"LexLeanStd.Text.trim"},{"construct":"type.bytes","instance":"LexLeanStd.Text.trimEnd"},{"construct":"type.bytes","instance":"LexLeanStd.Text.trimStart"}]},{"effect":"overflow","sources":[{"construct":"term.add","instance":"LexLeanStd.Text.trimStart"}]},{"effect":"recursion","sources":[{"construct":"primitive.iterate_until","instance":"LexLeanStd.Text.trimEnd"},{"construct":"primitive.iterate_until","instance":"LexLeanStd.Text.trimStart"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"},{"construct":"type.option","type":"Option (Nat)"},{"construct":"type.option","type":"Option (UInt8)"},{"construct":"type.product","type":"Prod (Nat) (Bool)"},{"construct":"type.uint8","type":"UInt8"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.splitStep"]},{"construct":"primitive.index","disposition":"runtime","instances":["LexLeanStd.Text.byteAt"]},{"construct":"primitive.iterate_until","disposition":"runtime","instances":["LexLeanStd.Text.splitOn"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.splitOn"]},{"construct":"primitive.list_fold","disposition":"runtime","instances":["LexLeanStd.Text.reverse"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr"]},{"construct":"primitive.subtract","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.add","disposition":"runtime","instances":["LexLeanStd.Text.splitStep"]},{"construct":"term.bytes","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr"]},{"construct":"term.call","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.cons","disposition":"runtime","instances":["LexLeanStd.Text.reverse","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.constructor","disposition":"runtime","instances":["LexLeanStd.Text.splitStep"]},{"construct":"term.first","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.if","disposition":"runtime","instances":["LexLeanStd.Text.splitStep"]},{"construct":"term.lambda","disposition":"runtime","instances":["LexLeanStd.Text.reverse","LexLeanStd.Text.splitOn"]},{"construct":"term.let","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitStep"]},{"construct":"term.nat","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.nil","disposition":"runtime","instances":["LexLeanStd.Text.reverse","LexLeanStd.Text.splitOn"]},{"construct":"term.pair","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.second","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.list","disposition":"runtime","instances":["LexLeanStd.Text.reverse","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitStep"]},{"construct":"type.product","disposition":"runtime","instances":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]},{"construct":"type.uint8","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"]}],"declared_effects":["allocation","overflow","recursion"],"erased":[],"root":"LexLeanStd.Text.splitOn","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.splitOn","instance":"LexLeanStd.Text.splitOn","path":["LexLeanStd.Text.splitOn"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.splitStep","instance":"LexLeanStd.Text.splitStep","path":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.reverse","instance":"LexLeanStd.Text.reverse","path":["LexLeanStd.Text.splitOn","LexLeanStd.Text.reverse"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","path":["LexLeanStd.Text.splitOn","LexLeanStd.Text.sliceOr"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","path":["LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep","LexLeanStd.Text.byteAt"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.sliceOr"},{"construct":"term.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"term.cons","instance":"LexLeanStd.Text.reverse"},{"construct":"term.cons","instance":"LexLeanStd.Text.splitOn"},{"construct":"term.cons","instance":"LexLeanStd.Text.splitStep"},{"construct":"type.bytes","instance":"LexLeanStd.Text.byteAt"},{"construct":"type.bytes","instance":"LexLeanStd.Text.reverse"},{"construct":"type.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"type.bytes","instance":"LexLeanStd.Text.splitOn"},{"construct":"type.bytes","instance":"LexLeanStd.Text.splitStep"},{"construct":"type.list","instance":"LexLeanStd.Text.reverse"},{"construct":"type.list","instance":"LexLeanStd.Text.splitOn"},{"construct":"type.list","instance":"LexLeanStd.Text.splitStep"}]},{"effect":"overflow","sources":[{"construct":"term.add","instance":"LexLeanStd.Text.splitStep"}]},{"effect":"recursion","sources":[{"construct":"primitive.iterate_until","instance":"LexLeanStd.Text.splitOn"},{"construct":"primitive.list_fold","instance":"LexLeanStd.Text.reverse"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.list","type":"List (ByteArray)"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"},{"construct":"type.option","type":"Option (Prod (Nat) (Prod (Nat) (List (ByteArray))))"},{"construct":"type.option","type":"Option (UInt8)"},{"construct":"type.product","type":"Prod (Nat) (List (ByteArray))"},{"construct":"type.product","type":"Prod (Nat) (Prod (Nat) (List (ByteArray)))"},{"construct":"type.product","type":"Prod (Prod (Nat) (Prod (Nat) (List (ByteArray)))) (Bool)"},{"construct":"type.uint8","type":"UInt8"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep"]},{"construct":"primitive.index","disposition":"runtime","instances":["LexLeanStd.Text.byteAt"]},{"construct":"primitive.iterate_until","disposition":"runtime","instances":["LexLeanStd.Text.lines"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lines"]},{"construct":"primitive.list_fold","disposition":"runtime","instances":["LexLeanStd.Text.reverse"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.endsWith","LexLeanStd.Text.sliceOr"]},{"construct":"primitive.subtract","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.add","disposition":"runtime","instances":["LexLeanStd.Text.lineStep"]},{"construct":"term.ble","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.blt","disposition":"runtime","instances":["LexLeanStd.Text.lines"]},{"construct":"term.bool","disposition":"runtime","instances":["LexLeanStd.Text.endsWith"]},{"construct":"term.bytes","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.sliceOr"]},{"construct":"term.call","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.cons","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse"]},{"construct":"term.constructor","disposition":"runtime","instances":["LexLeanStd.Text.lineStep"]},{"construct":"term.first","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.if","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.integer","disposition":"runtime","instances":["LexLeanStd.Text.lineStep"]},{"construct":"term.lambda","disposition":"runtime","instances":["LexLeanStd.Text.lines","LexLeanStd.Text.reverse"]},{"construct":"term.let","disposition":"runtime","instances":["LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.sliceOr"]},{"construct":"term.nat","disposition":"runtime","instances":["LexLeanStd.Text.chomp","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.nil","disposition":"runtime","instances":["LexLeanStd.Text.lines","LexLeanStd.Text.reverse"]},{"construct":"term.pair","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr"]},{"construct":"term.second","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr"]},{"construct":"type.list","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.sliceOr"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.sliceOr"]},{"construct":"type.product","disposition":"runtime","instances":["LexLeanStd.Text.lineStep","LexLeanStd.Text.lines"]},{"construct":"type.uint8","disposition":"runtime","instances":["LexLeanStd.Text.byteAt","LexLeanStd.Text.lineStep"]}],"declared_effects":["allocation","overflow","recursion"],"erased":[],"root":"LexLeanStd.Text.lines","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.lines","instance":"LexLeanStd.Text.lines","path":["LexLeanStd.Text.lines"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.lineStep","instance":"LexLeanStd.Text.lineStep","path":["LexLeanStd.Text.lines","LexLeanStd.Text.lineStep"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.reverse","instance":"LexLeanStd.Text.reverse","path":["LexLeanStd.Text.lines","LexLeanStd.Text.reverse"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","path":["LexLeanStd.Text.lines","LexLeanStd.Text.sliceOr"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","path":["LexLeanStd.Text.lines","LexLeanStd.Text.lineStep","LexLeanStd.Text.byteAt"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.chomp","instance":"LexLeanStd.Text.chomp","path":["LexLeanStd.Text.lines","LexLeanStd.Text.lineStep","LexLeanStd.Text.chomp"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.endsWith","instance":"LexLeanStd.Text.endsWith","path":["LexLeanStd.Text.lines","LexLeanStd.Text.lineStep","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.endsWith"},{"construct":"primitive.slice","instance":"LexLeanStd.Text.sliceOr"},{"construct":"term.bytes","instance":"LexLeanStd.Text.chomp"},{"construct":"term.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"term.cons","instance":"LexLeanStd.Text.lineStep"},{"construct":"term.cons","instance":"LexLeanStd.Text.lines"},{"construct":"term.cons","instance":"LexLeanStd.Text.reverse"},{"construct":"type.bytes","instance":"LexLeanStd.Text.byteAt"},{"construct":"type.bytes","instance":"LexLeanStd.Text.chomp"},{"construct":"type.bytes","instance":"LexLeanStd.Text.endsWith"},{"construct":"type.bytes","instance":"LexLeanStd.Text.lineStep"},{"construct":"type.bytes","instance":"LexLeanStd.Text.lines"},{"construct":"type.bytes","instance":"LexLeanStd.Text.reverse"},{"construct":"type.bytes","instance":"LexLeanStd.Text.sliceOr"},{"construct":"type.list","instance":"LexLeanStd.Text.lineStep"},{"construct":"type.list","instance":"LexLeanStd.Text.lines"},{"construct":"type.list","instance":"LexLeanStd.Text.reverse"}]},{"effect":"overflow","sources":[{"construct":"term.add","instance":"LexLeanStd.Text.lineStep"}]},{"effect":"recursion","sources":[{"construct":"primitive.iterate_until","instance":"LexLeanStd.Text.lines"},{"construct":"primitive.list_fold","instance":"LexLeanStd.Text.reverse"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.list","type":"List (ByteArray)"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"},{"construct":"type.option","type":"Option (Prod (Nat) (Prod (Nat) (List (ByteArray))))"},{"construct":"type.option","type":"Option (UInt8)"},{"construct":"type.product","type":"Prod (Nat) (List (ByteArray))"},{"construct":"type.product","type":"Prod (Nat) (Prod (Nat) (List (ByteArray)))"},{"construct":"type.product","type":"Prod (Prod (Nat) (Prod (Nat) (List (ByteArray)))) (Bool)"},{"construct":"type.uint8","type":"UInt8"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"primitive.append","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"primitive.list_fold","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.bytes","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.constructor","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.lambda","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"type.list","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.joinWith"]}],"declared_effects":["allocation","recursion"],"erased":[],"root":"LexLeanStd.Text.joinWith","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.joinWith","instance":"LexLeanStd.Text.joinWith","path":["LexLeanStd.Text.joinWith"],"type_arguments":[]}],"targets":[{"boundary":[],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.append","instance":"LexLeanStd.Text.joinWith"},{"construct":"term.bytes","instance":"LexLeanStd.Text.joinWith"},{"construct":"type.bytes","instance":"LexLeanStd.Text.joinWith"},{"construct":"type.list","instance":"LexLeanStd.Text.joinWith"}]},{"effect":"recursion","sources":[{"construct":"primitive.list_fold","instance":"LexLeanStd.Text.joinWith"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.list","type":"List (ByteArray)"},{"construct":"type.option","type":"Option (ByteArray)"}]},{"constructs":[{"construct":"declaration.definition","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"primitive.equal","disposition":"runtime","instances":["LexLeanStd.Text.matchAt"]},{"construct":"primitive.iterate_until","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"primitive.length","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"primitive.slice","disposition":"runtime","instances":["LexLeanStd.Text.matchAt"]},{"construct":"term.add","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.blt","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.bool","disposition":"runtime","instances":["LexLeanStd.Text.matchAt"]},{"construct":"term.call","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.constructor","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.first","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.if","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.lambda","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.let","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.match","disposition":"runtime","instances":["LexLeanStd.Text.matchAt"]},{"construct":"term.nat","disposition":"runtime","instances":["LexLeanStd.Text.find"]},{"construct":"term.primitive","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"term.var","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"type.bool","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"type.bytes","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"type.nat","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"type.option","disposition":"runtime","instances":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"]},{"construct":"type.product","disposition":"runtime","instances":["LexLeanStd.Text.find"]}],"declared_effects":["allocation","overflow","recursion"],"erased":[],"root":"LexLeanStd.Text.find","runtime_closure":[{"construct":"declaration.definition","declaration":"LexLeanStd.Text.find","instance":"LexLeanStd.Text.find","path":["LexLeanStd.Text.find"],"type_arguments":[]},{"construct":"declaration.definition","declaration":"LexLeanStd.Text.matchAt","instance":"LexLeanStd.Text.matchAt","path":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"],"type_arguments":[]}],"targets":[{"boundary":[{"bits":64,"position":"result","representation":"nat"}],"effects":[{"effect":"allocation","sources":[{"construct":"primitive.slice","instance":"LexLeanStd.Text.matchAt"},{"construct":"type.bytes","instance":"LexLeanStd.Text.find"},{"construct":"type.bytes","instance":"LexLeanStd.Text.matchAt"}]},{"effect":"overflow","sources":[{"construct":"term.add","instance":"LexLeanStd.Text.find"}]},{"effect":"recursion","sources":[{"construct":"primitive.iterate_until","instance":"LexLeanStd.Text.find"}]}],"status":"eligible","target":"rust-std"}],"types":[{"construct":"type.bool","type":"Bool"},{"construct":"type.bytes","type":"ByteArray"},{"construct":"type.nat","type":"Nat"},{"construct":"type.option","type":"Option (ByteArray)"},{"construct":"type.option","type":"Option (Nat)"},{"construct":"type.product","type":"Prod (Nat) (Bool)"}]}],"spec":"lexlean/production-eligibility/1"} diff --git a/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.lean b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.lean new file mode 100644 index 0000000000..ae0a214131 --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.lean @@ -0,0 +1,105 @@ +module +import LexLeanRuntime.Collections +#print axioms LexLeanCollections.Key +#print axioms LexLeanCollections.Key.casesOn +#print axioms LexLeanCollections.Key.compare +#print axioms LexLeanCollections.Key.ctorIdx +#print axioms LexLeanCollections.Key.mk._flat_ctor +#print axioms LexLeanCollections.Key.mk.noConfusion +#print axioms LexLeanCollections.Key.noConfusion +#print axioms LexLeanCollections.Key.noConfusionType +#print axioms LexLeanCollections.Key.recOn +#print axioms LexLeanCollections.compareCodes +#print axioms LexLeanCollections.compareCodes._f +#print axioms LexLeanCollections.compareCodes._sparseCasesOn_1 +#print axioms LexLeanCollections.compareCodes._sunfold +#print axioms LexLeanCollections.compareCodes._unsafe_rec +#print axioms LexLeanCollections.compareCodes.match_1 +#print axioms LexLeanCollections.compareCodes.match_4 +#print axioms LexLeanCollections.containsElement +#print axioms LexLeanCollections.containsElement._f +#print axioms LexLeanCollections.containsElement._sunfold +#print axioms LexLeanCollections.containsElement._unsafe_rec +#print axioms LexLeanCollections.graphNodes +#print axioms LexLeanCollections.graphReachable +#print axioms LexLeanCollections.graphSuccessors +#print axioms LexLeanCollections.graphTopological +#print axioms LexLeanCollections.insertElement +#print axioms LexLeanCollections.insertElement._f +#print axioms LexLeanCollections.insertElement._sunfold +#print axioms LexLeanCollections.insertElement._unsafe_rec +#print axioms LexLeanCollections.insertElement.match_1 +#print axioms LexLeanCollections.insertEntry +#print axioms LexLeanCollections.insertEntry._f +#print axioms LexLeanCollections.insertEntry._sunfold +#print axioms LexLeanCollections.insertEntry._unsafe_rec +#print axioms LexLeanCollections.insertEntry.match_1 +#print axioms LexLeanCollections.insertEntry.match_3 +#print axioms LexLeanCollections.instKeyBool +#print axioms LexLeanCollections.instKeyInt +#print axioms LexLeanCollections.instKeyInt16 +#print axioms LexLeanCollections.instKeyInt32 +#print axioms LexLeanCollections.instKeyInt64 +#print axioms LexLeanCollections.instKeyInt8 +#print axioms LexLeanCollections.instKeyNat +#print axioms LexLeanCollections.instKeyProd +#print axioms LexLeanCollections.instKeyString +#print axioms LexLeanCollections.instKeyUInt16 +#print axioms LexLeanCollections.instKeyUInt32 +#print axioms LexLeanCollections.instKeyUInt64 +#print axioms LexLeanCollections.instKeyUInt8 +#print axioms LexLeanCollections.iterate +#print axioms LexLeanCollections.iterate._f +#print axioms LexLeanCollections.iterate._sunfold +#print axioms LexLeanCollections.iterate._unsafe_rec +#print axioms LexLeanCollections.iterate.match_1 +#print axioms LexLeanCollections.iterateUntil +#print axioms LexLeanCollections.iterateUntil._f +#print axioms LexLeanCollections.iterateUntil._sunfold +#print axioms LexLeanCollections.iterateUntil._unsafe_rec +#print axioms LexLeanCollections.iterateUntil.match_1 +#print axioms LexLeanCollections.lessThan +#print axioms LexLeanCollections.lessThan._sparseCasesOn_1 +#print axioms LexLeanCollections.lessThan.match_1 +#print axioms LexLeanCollections.listFold +#print axioms LexLeanCollections.lookupEntry +#print axioms LexLeanCollections.lookupEntry._f +#print axioms LexLeanCollections.lookupEntry._sunfold +#print axioms LexLeanCollections.lookupEntry._unsafe_rec +#print axioms LexLeanCollections.mapContains +#print axioms LexLeanCollections.mapEntries +#print axioms LexLeanCollections.mapFold +#print axioms LexLeanCollections.mapInsert +#print axioms LexLeanCollections.mapKeys +#print axioms LexLeanCollections.mapLookup +#print axioms LexLeanCollections.mapRemove +#print axioms LexLeanCollections.mapSize +#print axioms LexLeanCollections.mapValues +#print axioms LexLeanCollections.reachableFrom +#print axioms LexLeanCollections.reachableFrom._f +#print axioms LexLeanCollections.reachableFrom._sparseCasesOn_1 +#print axioms LexLeanCollections.reachableFrom._sunfold +#print axioms LexLeanCollections.reachableFrom._unsafe_rec +#print axioms LexLeanCollections.reachableFrom.match_1 +#print axioms LexLeanCollections.reachableFrom.match_4 +#print axioms LexLeanCollections.removeElement +#print axioms LexLeanCollections.removeElement._f +#print axioms LexLeanCollections.removeElement._sunfold +#print axioms LexLeanCollections.removeElement._unsafe_rec +#print axioms LexLeanCollections.removeEntry +#print axioms LexLeanCollections.removeEntry._f +#print axioms LexLeanCollections.removeEntry._sunfold +#print axioms LexLeanCollections.removeEntry._unsafe_rec +#print axioms LexLeanCollections.setContains +#print axioms LexLeanCollections.setDifference +#print axioms LexLeanCollections.setElements +#print axioms LexLeanCollections.setFold +#print axioms LexLeanCollections.setInsert +#print axioms LexLeanCollections.setIntersection +#print axioms LexLeanCollections.setRemove +#print axioms LexLeanCollections.setSize +#print axioms LexLeanCollections.setUnion +#print axioms LexLeanCollections.topological +#print axioms LexLeanCollections.topological._f +#print axioms LexLeanCollections.topological._sunfold +#print axioms LexLeanCollections.topological._unsafe_rec diff --git a/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.process.json new file mode 100644 index 0000000000..ff4d54630c --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.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.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.lean b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.lean new file mode 100644 index 0000000000..dd62fd557f --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.lean @@ -0,0 +1,162 @@ +module +import LexLeanRuntime.Portable +#print axioms LexLeanRuntime.Appendable +#print axioms LexLeanRuntime.Appendable.append +#print axioms LexLeanRuntime.Appendable.casesOn +#print axioms LexLeanRuntime.Appendable.ctorIdx +#print axioms LexLeanRuntime.Appendable.mk._flat_ctor +#print axioms LexLeanRuntime.Appendable.mk.noConfusion +#print axioms LexLeanRuntime.Appendable.noConfusion +#print axioms LexLeanRuntime.Appendable.noConfusionType +#print axioms LexLeanRuntime.Appendable.recOn +#print axioms LexLeanRuntime.Decimal +#print axioms LexLeanRuntime.Decimal.casesOn +#print axioms LexLeanRuntime.Decimal.ctorIdx +#print axioms LexLeanRuntime.Decimal.format +#print axioms LexLeanRuntime.Decimal.mk._flat_ctor +#print axioms LexLeanRuntime.Decimal.mk.noConfusion +#print axioms LexLeanRuntime.Decimal.noConfusion +#print axioms LexLeanRuntime.Decimal.noConfusionType +#print axioms LexLeanRuntime.Decimal.parse +#print axioms LexLeanRuntime.Decimal.recOn +#print axioms LexLeanRuntime.Fixed +#print axioms LexLeanRuntime.Fixed.bitAnd +#print axioms LexLeanRuntime.Fixed.bitNot +#print axioms LexLeanRuntime.Fixed.bitOr +#print axioms LexLeanRuntime.Fixed.bitXor +#print axioms LexLeanRuntime.Fixed.casesOn +#print axioms LexLeanRuntime.Fixed.ctorIdx +#print axioms LexLeanRuntime.Fixed.fromInt +#print axioms LexLeanRuntime.Fixed.maximum +#print axioms LexLeanRuntime.Fixed.minimum +#print axioms LexLeanRuntime.Fixed.mk._flat_ctor +#print axioms LexLeanRuntime.Fixed.mk.noConfusion +#print axioms LexLeanRuntime.Fixed.noConfusion +#print axioms LexLeanRuntime.Fixed.noConfusionType +#print axioms LexLeanRuntime.Fixed.recOn +#print axioms LexLeanRuntime.Fixed.shiftLeft +#print axioms LexLeanRuntime.Fixed.shiftRight +#print axioms LexLeanRuntime.Fixed.toToMathInt +#print axioms LexLeanRuntime.Indexable +#print axioms LexLeanRuntime.Indexable.casesOn +#print axioms LexLeanRuntime.Indexable.ctorIdx +#print axioms LexLeanRuntime.Indexable.index +#print axioms LexLeanRuntime.Indexable.mk._flat_ctor +#print axioms LexLeanRuntime.Indexable.mk.noConfusion +#print axioms LexLeanRuntime.Indexable.noConfusion +#print axioms LexLeanRuntime.Indexable.noConfusionType +#print axioms LexLeanRuntime.Indexable.recOn +#print axioms LexLeanRuntime.Lengthable +#print axioms LexLeanRuntime.Lengthable.casesOn +#print axioms LexLeanRuntime.Lengthable.ctorIdx +#print axioms LexLeanRuntime.Lengthable.length +#print axioms LexLeanRuntime.Lengthable.mk._flat_ctor +#print axioms LexLeanRuntime.Lengthable.mk.noConfusion +#print axioms LexLeanRuntime.Lengthable.noConfusion +#print axioms LexLeanRuntime.Lengthable.noConfusionType +#print axioms LexLeanRuntime.Lengthable.recOn +#print axioms LexLeanRuntime.Quotient +#print axioms LexLeanRuntime.Quotient.casesOn +#print axioms LexLeanRuntime.Quotient.ctorIdx +#print axioms LexLeanRuntime.Quotient.isZero +#print axioms LexLeanRuntime.Quotient.mk._flat_ctor +#print axioms LexLeanRuntime.Quotient.mk.noConfusion +#print axioms LexLeanRuntime.Quotient.noConfusion +#print axioms LexLeanRuntime.Quotient.noConfusionType +#print axioms LexLeanRuntime.Quotient.quotient +#print axioms LexLeanRuntime.Quotient.recOn +#print axioms LexLeanRuntime.Quotient.remainder +#print axioms LexLeanRuntime.Sliceable +#print axioms LexLeanRuntime.Sliceable.casesOn +#print axioms LexLeanRuntime.Sliceable.ctorIdx +#print axioms LexLeanRuntime.Sliceable.mk._flat_ctor +#print axioms LexLeanRuntime.Sliceable.mk.noConfusion +#print axioms LexLeanRuntime.Sliceable.noConfusion +#print axioms LexLeanRuntime.Sliceable.noConfusionType +#print axioms LexLeanRuntime.Sliceable.recOn +#print axioms LexLeanRuntime.Sliceable.slice +#print axioms LexLeanRuntime.ToMathInt +#print axioms LexLeanRuntime.ToMathInt.casesOn +#print axioms LexLeanRuntime.ToMathInt.ctorIdx +#print axioms LexLeanRuntime.ToMathInt.mk._flat_ctor +#print axioms LexLeanRuntime.ToMathInt.mk.noConfusion +#print axioms LexLeanRuntime.ToMathInt.noConfusion +#print axioms LexLeanRuntime.ToMathInt.noConfusionType +#print axioms LexLeanRuntime.ToMathInt.recOn +#print axioms LexLeanRuntime.ToMathInt.toInt +#print axioms LexLeanRuntime.append +#print axioms LexLeanRuntime.bitAnd +#print axioms LexLeanRuntime.bitNot +#print axioms LexLeanRuntime.bitOr +#print axioms LexLeanRuntime.bitXor +#print axioms LexLeanRuntime.checkedAdd +#print axioms LexLeanRuntime.checkedAddInt64 +#print axioms LexLeanRuntime.checkedConvert +#print axioms LexLeanRuntime.checkedFromInt +#print axioms LexLeanRuntime.checkedMultiply +#print axioms LexLeanRuntime.checkedMultiplyInt64 +#print axioms LexLeanRuntime.checkedMultiplyInt64.match_1 +#print axioms LexLeanRuntime.checkedNegate +#print axioms LexLeanRuntime.checkedNegateInt64 +#print axioms LexLeanRuntime.checkedQuotient +#print axioms LexLeanRuntime.checkedQuotientInt64 +#print axioms LexLeanRuntime.checkedSubtract +#print axioms LexLeanRuntime.checkedSubtractInt64 +#print axioms LexLeanRuntime.compareBytes +#print axioms LexLeanRuntime.divideMagnitudeInt64 +#print axioms LexLeanRuntime.divideMagnitudeInt64._f +#print axioms LexLeanRuntime.divideMagnitudeInt64._sunfold +#print axioms LexLeanRuntime.divideMagnitudeInt64._unsafe_rec +#print axioms LexLeanRuntime.divideMagnitudeInt64.match_1 +#print axioms LexLeanRuntime.equal +#print axioms LexLeanRuntime.formatDecimal +#print axioms LexLeanRuntime.index +#print axioms LexLeanRuntime.instAppendableByteArray +#print axioms LexLeanRuntime.instAppendableList +#print axioms LexLeanRuntime.instDecimalInt +#print axioms LexLeanRuntime.instDecimalInt.match_1 +#print axioms LexLeanRuntime.instDecimalOfFixedOfToString +#print axioms LexLeanRuntime.instFixedInt16 +#print axioms LexLeanRuntime.instFixedInt32 +#print axioms LexLeanRuntime.instFixedInt64 +#print axioms LexLeanRuntime.instFixedInt8 +#print axioms LexLeanRuntime.instFixedUInt16 +#print axioms LexLeanRuntime.instFixedUInt32 +#print axioms LexLeanRuntime.instFixedUInt64 +#print axioms LexLeanRuntime.instFixedUInt8 +#print axioms LexLeanRuntime.instIndexableByteArrayUInt8 +#print axioms LexLeanRuntime.instIndexableList +#print axioms LexLeanRuntime.instLengthableByteArray +#print axioms LexLeanRuntime.instLengthableList +#print axioms LexLeanRuntime.instLengthableString +#print axioms LexLeanRuntime.instQuotientInt +#print axioms LexLeanRuntime.instQuotientNat +#print axioms LexLeanRuntime.instSliceableByteArray +#print axioms LexLeanRuntime.instSliceableList +#print axioms LexLeanRuntime.instToMathIntInt +#print axioms LexLeanRuntime.join +#print axioms LexLeanRuntime.length +#print axioms LexLeanRuntime.listIndex +#print axioms LexLeanRuntime.listIndex._f +#print axioms LexLeanRuntime.listIndex._sunfold +#print axioms LexLeanRuntime.listIndex._unsafe_rec +#print axioms LexLeanRuntime.listIndex.match_1 +#print axioms LexLeanRuntime.magnitudeInt64 +#print axioms LexLeanRuntime.multiply +#print axioms LexLeanRuntime.multiplyMagnitudeInt64 +#print axioms LexLeanRuntime.multiplyMagnitudeInt64._f +#print axioms LexLeanRuntime.multiplyMagnitudeInt64._sunfold +#print axioms LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec +#print axioms LexLeanRuntime.multiplyMagnitudeInt64.match_1 +#print axioms LexLeanRuntime.negate +#print axioms LexLeanRuntime.parseDecimal +#print axioms LexLeanRuntime.quotient +#print axioms LexLeanRuntime.remainder +#print axioms LexLeanRuntime.shiftLeft +#print axioms LexLeanRuntime.shiftRight +#print axioms LexLeanRuntime.signedMagnitudeInt64 +#print axioms LexLeanRuntime.slice +#print axioms LexLeanRuntime.splitExact +#print axioms LexLeanRuntime.subtract +#print axioms LexLeanRuntime.utf8Decode +#print axioms LexLeanRuntime.utf8Encode diff --git a/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.process.json new file mode 100644 index 0000000000..e25ce372b4 --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanRuntime.Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.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.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.lean b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.lean new file mode 100644 index 0000000000..56abee5532 --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.lean @@ -0,0 +1,20 @@ +module +import LexLeanStd.Text +#print axioms LexLeanStd.Text.byteAt +#print axioms LexLeanStd.Text.chomp +#print axioms LexLeanStd.Text.endsWith +#print axioms LexLeanStd.Text.find +#print axioms LexLeanStd.Text.isSpace +#print axioms LexLeanStd.Text.joinWith +#print axioms LexLeanStd.Text.lineStep +#print axioms LexLeanStd.Text.lines +#print axioms LexLeanStd.Text.matchAt +#print axioms LexLeanStd.Text.reverse +#print axioms LexLeanStd.Text.sliceOr +#print axioms LexLeanStd.Text.spaceAt +#print axioms LexLeanStd.Text.splitOn +#print axioms LexLeanStd.Text.splitStep +#print axioms LexLeanStd.Text.startsWith +#print axioms LexLeanStd.Text.trim +#print axioms LexLeanStd.Text.trimEnd +#print axioms LexLeanStd.Text.trimStart diff --git a/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.process.json b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.process.json new file mode 100644 index 0000000000..f83af0dcd3 --- /dev/null +++ b/stdlib/expected/verify/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/audit/LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.LexLeanStd.Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanAudit.Ab4a41a9b6af3776bed9cd860f1a4f2d9.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/audit/output.txt b/stdlib/expected/verify/audit/output.txt new file mode 100644 index 0000000000..14e6c8769b --- /dev/null +++ b/stdlib/expected/verify/audit/output.txt @@ -0,0 +1,281 @@ +'LexLeanCollections.Key' does not depend on any axioms +'LexLeanCollections.Key.casesOn' does not depend on any axioms +'LexLeanCollections.Key.compare' does not depend on any axioms +'LexLeanCollections.Key.ctorIdx' does not depend on any axioms +'LexLeanCollections.Key.mk._flat_ctor' does not depend on any axioms +'LexLeanCollections.Key.mk.noConfusion' does not depend on any axioms +'LexLeanCollections.Key.noConfusion' does not depend on any axioms +'LexLeanCollections.Key.noConfusionType' does not depend on any axioms +'LexLeanCollections.Key.recOn' does not depend on any axioms +'LexLeanCollections.compareCodes' depends on axioms: [propext] +'LexLeanCollections.compareCodes._f' depends on axioms: [propext] +'LexLeanCollections.compareCodes._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanCollections.compareCodes._sunfold' depends on axioms: [propext] +'LexLeanCollections.compareCodes._unsafe_rec' depends on axioms: [propext] +'LexLeanCollections.compareCodes.match_1' depends on axioms: [propext] +'LexLeanCollections.compareCodes.match_4' does not depend on any axioms +'LexLeanCollections.containsElement' does not depend on any axioms +'LexLeanCollections.containsElement._f' does not depend on any axioms +'LexLeanCollections.containsElement._sunfold' does not depend on any axioms +'LexLeanCollections.containsElement._unsafe_rec' does not depend on any axioms +'LexLeanCollections.graphNodes' does not depend on any axioms +'LexLeanCollections.graphReachable' depends on axioms: [propext] +'LexLeanCollections.graphSuccessors' does not depend on any axioms +'LexLeanCollections.graphTopological' does not depend on any axioms +'LexLeanCollections.insertElement' does not depend on any axioms +'LexLeanCollections.insertElement._f' does not depend on any axioms +'LexLeanCollections.insertElement._sunfold' does not depend on any axioms +'LexLeanCollections.insertElement._unsafe_rec' does not depend on any axioms +'LexLeanCollections.insertElement.match_1' does not depend on any axioms +'LexLeanCollections.insertEntry' does not depend on any axioms +'LexLeanCollections.insertEntry._f' does not depend on any axioms +'LexLeanCollections.insertEntry._sunfold' does not depend on any axioms +'LexLeanCollections.insertEntry._unsafe_rec' does not depend on any axioms +'LexLeanCollections.insertEntry.match_1' does not depend on any axioms +'LexLeanCollections.insertEntry.match_3' does not depend on any axioms +'LexLeanCollections.instKeyBool' depends on axioms: [propext] +'LexLeanCollections.instKeyInt' does not depend on any axioms +'LexLeanCollections.instKeyInt16' does not depend on any axioms +'LexLeanCollections.instKeyInt32' does not depend on any axioms +'LexLeanCollections.instKeyInt64' does not depend on any axioms +'LexLeanCollections.instKeyInt8' does not depend on any axioms +'LexLeanCollections.instKeyNat' does not depend on any axioms +'LexLeanCollections.instKeyProd' depends on axioms: [propext] +'LexLeanCollections.instKeyString' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanCollections.instKeyUInt16' does not depend on any axioms +'LexLeanCollections.instKeyUInt32' does not depend on any axioms +'LexLeanCollections.instKeyUInt64' does not depend on any axioms +'LexLeanCollections.instKeyUInt8' does not depend on any axioms +'LexLeanCollections.iterate' does not depend on any axioms +'LexLeanCollections.iterate._f' does not depend on any axioms +'LexLeanCollections.iterate._sunfold' does not depend on any axioms +'LexLeanCollections.iterate._unsafe_rec' does not depend on any axioms +'LexLeanCollections.iterate.match_1' does not depend on any axioms +'LexLeanCollections.iterateUntil' does not depend on any axioms +'LexLeanCollections.iterateUntil._f' does not depend on any axioms +'LexLeanCollections.iterateUntil._sunfold' does not depend on any axioms +'LexLeanCollections.iterateUntil._unsafe_rec' does not depend on any axioms +'LexLeanCollections.iterateUntil.match_1' does not depend on any axioms +'LexLeanCollections.lessThan' depends on axioms: [propext] +'LexLeanCollections.lessThan._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanCollections.lessThan.match_1' depends on axioms: [propext] +'LexLeanCollections.listFold' does not depend on any axioms +'LexLeanCollections.lookupEntry' does not depend on any axioms +'LexLeanCollections.lookupEntry._f' does not depend on any axioms +'LexLeanCollections.lookupEntry._sunfold' does not depend on any axioms +'LexLeanCollections.lookupEntry._unsafe_rec' does not depend on any axioms +'LexLeanCollections.mapContains' does not depend on any axioms +'LexLeanCollections.mapEntries' does not depend on any axioms +'LexLeanCollections.mapFold' does not depend on any axioms +'LexLeanCollections.mapInsert' does not depend on any axioms +'LexLeanCollections.mapKeys' does not depend on any axioms +'LexLeanCollections.mapLookup' does not depend on any axioms +'LexLeanCollections.mapRemove' does not depend on any axioms +'LexLeanCollections.mapSize' does not depend on any axioms +'LexLeanCollections.mapValues' does not depend on any axioms +'LexLeanCollections.reachableFrom' depends on axioms: [propext] +'LexLeanCollections.reachableFrom._f' depends on axioms: [propext] +'LexLeanCollections.reachableFrom._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanCollections.reachableFrom._sunfold' depends on axioms: [propext] +'LexLeanCollections.reachableFrom._unsafe_rec' depends on axioms: [propext] +'LexLeanCollections.reachableFrom.match_1' depends on axioms: [propext] +'LexLeanCollections.reachableFrom.match_4' does not depend on any axioms +'LexLeanCollections.removeElement' does not depend on any axioms +'LexLeanCollections.removeElement._f' does not depend on any axioms +'LexLeanCollections.removeElement._sunfold' does not depend on any axioms +'LexLeanCollections.removeElement._unsafe_rec' does not depend on any axioms +'LexLeanCollections.removeEntry' does not depend on any axioms +'LexLeanCollections.removeEntry._f' does not depend on any axioms +'LexLeanCollections.removeEntry._sunfold' does not depend on any axioms +'LexLeanCollections.removeEntry._unsafe_rec' does not depend on any axioms +'LexLeanCollections.setContains' does not depend on any axioms +'LexLeanCollections.setDifference' does not depend on any axioms +'LexLeanCollections.setElements' does not depend on any axioms +'LexLeanCollections.setFold' does not depend on any axioms +'LexLeanCollections.setInsert' does not depend on any axioms +'LexLeanCollections.setIntersection' does not depend on any axioms +'LexLeanCollections.setRemove' does not depend on any axioms +'LexLeanCollections.setSize' does not depend on any axioms +'LexLeanCollections.setUnion' does not depend on any axioms +'LexLeanCollections.topological' does not depend on any axioms +'LexLeanCollections.topological._f' does not depend on any axioms +'LexLeanCollections.topological._sunfold' does not depend on any axioms +'LexLeanCollections.topological._unsafe_rec' does not depend on any axioms +'LexLeanRuntime.Appendable' does not depend on any axioms +'LexLeanRuntime.Appendable.append' does not depend on any axioms +'LexLeanRuntime.Appendable.casesOn' does not depend on any axioms +'LexLeanRuntime.Appendable.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Appendable.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Appendable.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Appendable.noConfusion' does not depend on any axioms +'LexLeanRuntime.Appendable.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Appendable.recOn' does not depend on any axioms +'LexLeanRuntime.Decimal' does not depend on any axioms +'LexLeanRuntime.Decimal.casesOn' does not depend on any axioms +'LexLeanRuntime.Decimal.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Decimal.format' does not depend on any axioms +'LexLeanRuntime.Decimal.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Decimal.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Decimal.noConfusion' does not depend on any axioms +'LexLeanRuntime.Decimal.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Decimal.parse' does not depend on any axioms +'LexLeanRuntime.Decimal.recOn' does not depend on any axioms +'LexLeanRuntime.Fixed' does not depend on any axioms +'LexLeanRuntime.Fixed.bitAnd' does not depend on any axioms +'LexLeanRuntime.Fixed.bitNot' does not depend on any axioms +'LexLeanRuntime.Fixed.bitOr' does not depend on any axioms +'LexLeanRuntime.Fixed.bitXor' does not depend on any axioms +'LexLeanRuntime.Fixed.casesOn' does not depend on any axioms +'LexLeanRuntime.Fixed.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Fixed.fromInt' does not depend on any axioms +'LexLeanRuntime.Fixed.maximum' does not depend on any axioms +'LexLeanRuntime.Fixed.minimum' does not depend on any axioms +'LexLeanRuntime.Fixed.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Fixed.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Fixed.noConfusion' does not depend on any axioms +'LexLeanRuntime.Fixed.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Fixed.recOn' does not depend on any axioms +'LexLeanRuntime.Fixed.shiftLeft' does not depend on any axioms +'LexLeanRuntime.Fixed.shiftRight' does not depend on any axioms +'LexLeanRuntime.Fixed.toToMathInt' does not depend on any axioms +'LexLeanRuntime.Indexable' does not depend on any axioms +'LexLeanRuntime.Indexable.casesOn' does not depend on any axioms +'LexLeanRuntime.Indexable.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Indexable.index' does not depend on any axioms +'LexLeanRuntime.Indexable.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Indexable.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Indexable.noConfusion' does not depend on any axioms +'LexLeanRuntime.Indexable.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Indexable.recOn' does not depend on any axioms +'LexLeanRuntime.Lengthable' does not depend on any axioms +'LexLeanRuntime.Lengthable.casesOn' does not depend on any axioms +'LexLeanRuntime.Lengthable.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Lengthable.length' does not depend on any axioms +'LexLeanRuntime.Lengthable.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Lengthable.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Lengthable.noConfusion' does not depend on any axioms +'LexLeanRuntime.Lengthable.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Lengthable.recOn' does not depend on any axioms +'LexLeanRuntime.Quotient' does not depend on any axioms +'LexLeanRuntime.Quotient.casesOn' does not depend on any axioms +'LexLeanRuntime.Quotient.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Quotient.isZero' does not depend on any axioms +'LexLeanRuntime.Quotient.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Quotient.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Quotient.noConfusion' does not depend on any axioms +'LexLeanRuntime.Quotient.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Quotient.quotient' does not depend on any axioms +'LexLeanRuntime.Quotient.recOn' does not depend on any axioms +'LexLeanRuntime.Quotient.remainder' does not depend on any axioms +'LexLeanRuntime.Sliceable' does not depend on any axioms +'LexLeanRuntime.Sliceable.casesOn' does not depend on any axioms +'LexLeanRuntime.Sliceable.ctorIdx' does not depend on any axioms +'LexLeanRuntime.Sliceable.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.Sliceable.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.Sliceable.noConfusion' does not depend on any axioms +'LexLeanRuntime.Sliceable.noConfusionType' does not depend on any axioms +'LexLeanRuntime.Sliceable.recOn' does not depend on any axioms +'LexLeanRuntime.Sliceable.slice' does not depend on any axioms +'LexLeanRuntime.ToMathInt' does not depend on any axioms +'LexLeanRuntime.ToMathInt.casesOn' does not depend on any axioms +'LexLeanRuntime.ToMathInt.ctorIdx' does not depend on any axioms +'LexLeanRuntime.ToMathInt.mk._flat_ctor' does not depend on any axioms +'LexLeanRuntime.ToMathInt.mk.noConfusion' does not depend on any axioms +'LexLeanRuntime.ToMathInt.noConfusion' does not depend on any axioms +'LexLeanRuntime.ToMathInt.noConfusionType' does not depend on any axioms +'LexLeanRuntime.ToMathInt.recOn' does not depend on any axioms +'LexLeanRuntime.ToMathInt.toInt' does not depend on any axioms +'LexLeanRuntime.append' does not depend on any axioms +'LexLeanRuntime.bitAnd' does not depend on any axioms +'LexLeanRuntime.bitNot' does not depend on any axioms +'LexLeanRuntime.bitOr' does not depend on any axioms +'LexLeanRuntime.bitXor' does not depend on any axioms +'LexLeanRuntime.checkedAdd' does not depend on any axioms +'LexLeanRuntime.checkedAddInt64' does not depend on any axioms +'LexLeanRuntime.checkedConvert' does not depend on any axioms +'LexLeanRuntime.checkedFromInt' does not depend on any axioms +'LexLeanRuntime.checkedMultiply' does not depend on any axioms +'LexLeanRuntime.checkedMultiplyInt64' does not depend on any axioms +'LexLeanRuntime.checkedMultiplyInt64.match_1' does not depend on any axioms +'LexLeanRuntime.checkedNegate' does not depend on any axioms +'LexLeanRuntime.checkedNegateInt64' does not depend on any axioms +'LexLeanRuntime.checkedQuotient' does not depend on any axioms +'LexLeanRuntime.checkedQuotientInt64' does not depend on any axioms +'LexLeanRuntime.checkedSubtract' does not depend on any axioms +'LexLeanRuntime.checkedSubtractInt64' does not depend on any axioms +'LexLeanRuntime.compareBytes' depends on axioms: [propext] +'LexLeanRuntime.divideMagnitudeInt64' does not depend on any axioms +'LexLeanRuntime.divideMagnitudeInt64._f' does not depend on any axioms +'LexLeanRuntime.divideMagnitudeInt64._sunfold' does not depend on any axioms +'LexLeanRuntime.divideMagnitudeInt64._unsafe_rec' does not depend on any axioms +'LexLeanRuntime.divideMagnitudeInt64.match_1' does not depend on any axioms +'LexLeanRuntime.equal' does not depend on any axioms +'LexLeanRuntime.formatDecimal' does not depend on any axioms +'LexLeanRuntime.index' does not depend on any axioms +'LexLeanRuntime.instAppendableByteArray' does not depend on any axioms +'LexLeanRuntime.instAppendableList' does not depend on any axioms +'LexLeanRuntime.instDecimalInt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.instDecimalInt.match_1' does not depend on any axioms +'LexLeanRuntime.instDecimalOfFixedOfToString' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.instFixedInt16' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedInt32' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedInt64' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedInt8' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedUInt16' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedUInt32' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedUInt64' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instFixedUInt8' depends on axioms: [propext, Quot.sound] +'LexLeanRuntime.instIndexableByteArrayUInt8' does not depend on any axioms +'LexLeanRuntime.instIndexableList' does not depend on any axioms +'LexLeanRuntime.instLengthableByteArray' does not depend on any axioms +'LexLeanRuntime.instLengthableList' does not depend on any axioms +'LexLeanRuntime.instLengthableString' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.instQuotientInt' does not depend on any axioms +'LexLeanRuntime.instQuotientNat' does not depend on any axioms +'LexLeanRuntime.instSliceableByteArray' does not depend on any axioms +'LexLeanRuntime.instSliceableList' does not depend on any axioms +'LexLeanRuntime.instToMathIntInt' does not depend on any axioms +'LexLeanRuntime.join' depends on axioms: [propext] +'LexLeanRuntime.length' does not depend on any axioms +'LexLeanRuntime.listIndex' does not depend on any axioms +'LexLeanRuntime.listIndex._f' does not depend on any axioms +'LexLeanRuntime.listIndex._sunfold' does not depend on any axioms +'LexLeanRuntime.listIndex._unsafe_rec' does not depend on any axioms +'LexLeanRuntime.listIndex.match_1' does not depend on any axioms +'LexLeanRuntime.magnitudeInt64' does not depend on any axioms +'LexLeanRuntime.multiply' does not depend on any axioms +'LexLeanRuntime.multiplyMagnitudeInt64' does not depend on any axioms +'LexLeanRuntime.multiplyMagnitudeInt64._f' does not depend on any axioms +'LexLeanRuntime.multiplyMagnitudeInt64._sunfold' does not depend on any axioms +'LexLeanRuntime.multiplyMagnitudeInt64._unsafe_rec' does not depend on any axioms +'LexLeanRuntime.multiplyMagnitudeInt64.match_1' does not depend on any axioms +'LexLeanRuntime.negate' does not depend on any axioms +'LexLeanRuntime.parseDecimal' does not depend on any axioms +'LexLeanRuntime.quotient' does not depend on any axioms +'LexLeanRuntime.remainder' does not depend on any axioms +'LexLeanRuntime.shiftLeft' does not depend on any axioms +'LexLeanRuntime.shiftRight' does not depend on any axioms +'LexLeanRuntime.signedMagnitudeInt64' does not depend on any axioms +'LexLeanRuntime.slice' does not depend on any axioms +'LexLeanRuntime.splitExact' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.subtract' does not depend on any axioms +'LexLeanRuntime.utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.utf8Encode' does not depend on any axioms +'LexLeanStd.Text.byteAt' does not depend on any axioms +'LexLeanStd.Text.chomp' does not depend on any axioms +'LexLeanStd.Text.endsWith' does not depend on any axioms +'LexLeanStd.Text.find' does not depend on any axioms +'LexLeanStd.Text.isSpace' does not depend on any axioms +'LexLeanStd.Text.joinWith' does not depend on any axioms +'LexLeanStd.Text.lineStep' does not depend on any axioms +'LexLeanStd.Text.lines' does not depend on any axioms +'LexLeanStd.Text.matchAt' does not depend on any axioms +'LexLeanStd.Text.reverse' does not depend on any axioms +'LexLeanStd.Text.sliceOr' does not depend on any axioms +'LexLeanStd.Text.spaceAt' does not depend on any axioms +'LexLeanStd.Text.splitOn' does not depend on any axioms +'LexLeanStd.Text.splitStep' does not depend on any axioms +'LexLeanStd.Text.startsWith' does not depend on any axioms +'LexLeanStd.Text.trim' does not depend on any axioms +'LexLeanStd.Text.trimEnd' does not depend on any axioms +'LexLeanStd.Text.trimStart' does not depend on any axioms diff --git a/stdlib/expected/verify/extract/LexLeanExtract.Xb4a41a9b6af3776bed9cd860f1a4f2d9.lean b/stdlib/expected/verify/extract/LexLeanExtract.Xb4a41a9b6af3776bed9cd860f1a4f2d9.lean new file mode 100644 index 0000000000..763ed1459e --- /dev/null +++ b/stdlib/expected/verify/extract/LexLeanExtract.Xb4a41a9b6af3776bed9cd860f1a4f2d9.lean @@ -0,0 +1,433 @@ +module +public meta import Lean +import all LexLeanRuntime.Portable +import all LexLeanRuntime.Collections +import all LexLeanStd.Text +set_option autoImplicit false +set_option linter.unusedVariables false +universe u u_1 u_2 v w + +meta def LexLeanExtract.escape (text : String) : String := + (String.foldl (α := String) (fun (out : String) (c : Char) => (if (BEq.beq (α := Char) c '"') then (String.append out "\\\"") else (if (BEq.beq (α := Char) c '\\') then (String.append out "\\\\") else (if (Nat.blt (Char.toNat c) 32) then (String.append out (String.append "\\u" (String.ofList (List.drop (α := Char) 1 (Nat.toDigits 16 (Nat.add (Char.toNat c) 65536)))))) else (String.push out c))))) "" text) + +meta def LexLeanExtract.str (text : String) : String := + (String.append "\"" (String.append (LexLeanExtract.escape text) "\"")) + +meta def LexLeanExtract.name (n : Lean.Name) : String := + (LexLeanExtract.str (Lean.Name.toString n)) + +meta def LexLeanExtract.arr (items : (List String)) : String := + (String.append "[" (String.append (String.intercalate "," items) "]")) + +meta def LexLeanExtract.obj (fields : (List (Prod String String))) : String := + (String.append "{" (String.append (String.intercalate "," (List.map (α := (Prod String String)) (β := String) (fun (kv : (Prod String String)) => (String.append (LexLeanExtract.str (kv).fst) (String.append ":" (kv).snd))) fields)) "}")) + +meta def LexLeanExtract.bool (value : Bool) : String := + (if value then "true" else "false") + +meta def LexLeanExtract.fvar (id : Lean.FVarId) : String := + (LexLeanExtract.name (id).name) + +meta partial def LexLeanExtract.mergeNames (a : (List Lean.Name)) (b : (List Lean.Name)) : (List Lean.Name) := + (match a with | .nil => b | .cons x xs => (match b with | .nil => a | .cons y ys => (if (Lean.Name.lt y x) then (List.cons (α := Lean.Name) y (LexLeanExtract.mergeNames a ys)) else (List.cons (α := Lean.Name) x (LexLeanExtract.mergeNames xs b))))) + +meta partial def LexLeanExtract.splitNames (l : (List Lean.Name)) : (Prod (List Lean.Name) (List Lean.Name)) := + (match l with | .nil => (Prod.mk (α := (List Lean.Name)) (β := (List Lean.Name)) (List.nil (α := Lean.Name)) (List.nil (α := Lean.Name))) | .cons x xs => (let rest : (Prod (List Lean.Name) (List Lean.Name)) := (LexLeanExtract.splitNames xs); (Prod.mk (α := (List Lean.Name)) (β := (List Lean.Name)) (List.cons (α := Lean.Name) x (rest).snd) (rest).fst))) + +meta partial def LexLeanExtract.sortNames (l : (List Lean.Name)) : (List Lean.Name) := + (match l with | .nil => (List.nil (α := Lean.Name)) | .cons x xs => (match xs with | .nil => l | .cons y ys => (let halves : (Prod (List Lean.Name) (List Lean.Name)) := (LexLeanExtract.splitNames l); (LexLeanExtract.mergeNames (LexLeanExtract.sortNames (halves).fst) (LexLeanExtract.sortNames (halves).snd))))) + +meta def LexLeanExtract.sorted (names : (Std.HashSet Lean.Name)) : (List Lean.Name) := + (LexLeanExtract.sortNames (Std.HashSet.toList (α := Lean.Name) names)) + +meta def LexLeanExtract.insert (names : (Std.HashSet Lean.Name)) (n : Lean.Name) : (Std.HashSet Lean.Name) := + (Std.HashSet.insert (α := Lean.Name) names n) + +meta partial def LexLeanExtract.type (e : Lean.Expr) : String := + (match e with | .const n us => (if (BEq.beq (α := Lean.Name) n ``lcErased) then (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "erased"))] : List (Prod String String)))) else (if (BEq.beq (α := Lean.Name) n ``lcAny) then (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "any"))] : List (Prod String String)))) else (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "const")), (Prod.mk (α := String) (β := String) "name" (LexLeanExtract.name n)), (Prod.mk (α := String) (β := String) "levels" (LexLeanExtract.arr (List.map (α := Lean.Level) (β := String) (fun (u : Lean.Level) => (LexLeanExtract.str (ToString.toString (α := Lean.Level) u))) us)))] : List (Prod String String)))))) | .app fn arg => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "app")), (Prod.mk (α := String) (β := String) "head" (LexLeanExtract.type (Lean.Expr.getAppFn e))), (Prod.mk (α := String) (β := String) "arguments" (LexLeanExtract.arr (List.map (α := Lean.Expr) (β := String) (fun (a : Lean.Expr) => (LexLeanExtract.type a)) (Array.toList (α := Lean.Expr) (Lean.Expr.getAppArgs e)))))] : List (Prod String String)))) | .forallE binderName domain body binderInfo => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "arrow")), (Prod.mk (α := String) (β := String) "domain" (LexLeanExtract.type domain)), (Prod.mk (α := String) (β := String) "codomain" (LexLeanExtract.type body))] : List (Prod String String)))) | .fvar id => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "fvar")), (Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar id))] : List (Prod String String)))) | .bvar position => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "bvar")), (Prod.mk (α := String) (β := String) "index" (ToString.toString (α := Nat) position))] : List (Prod String String)))) | .sort u => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "sort")), (Prod.mk (α := String) (β := String) "level" (LexLeanExtract.str (ToString.toString (α := Lean.Level) u)))] : List (Prod String String)))) | .mvar id => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "metavariable"))] : List (Prod String String)))) | .lam binderName domain body binderInfo => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "lambda"))] : List (Prod String String)))) | .letE declName t value body nonDep => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "let"))] : List (Prod String String)))) | .lit literal => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "literal"))] : List (Prod String String)))) | .mdata data body => (match (Lean.annotation? (Lean.Name.mkSimple "borrowed") e) with | .some annotated => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "borrowed")), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type body))] : List (Prod String String)))) | .none => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "metadata"))] : List (Prod String String))))) | .proj typeName idx struct => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unsupported")), (Prod.mk (α := String) (β := String) "expression" (LexLeanExtract.str "projection"))] : List (Prod String String))))) + +meta def LexLeanExtract.arg (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) : String := + (match a with | .erased => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "erased"))] : List (Prod String String)))) | .fvar id => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "fvar")), (Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar id))] : List (Prod String String)))) | .type e => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "type")), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type e))] : List (Prod String String))))) + +meta def LexLeanExtract.literal (value : Lean.Compiler.LCNF.LitValue) : String := + (match value with | .nat v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "nat")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) v)))] : List (Prod String String)))) | .str v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "string")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str v))] : List (Prod String String)))) | .uint8 v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "uint8")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) (UInt8.toNat v))))] : List (Prod String String)))) | .uint16 v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "uint16")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) (UInt16.toNat v))))] : List (Prod String String)))) | .uint32 v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "uint32")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) (UInt32.toNat v))))] : List (Prod String String)))) | .uint64 v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "uint64")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) (UInt64.toNat v))))] : List (Prod String String)))) | .usize v => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "usize")), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.str (ToString.toString (α := Nat) (UInt64.toNat v))))] : List (Prod String String))))) + +meta def LexLeanExtract.letValue (v : (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure)) : String := + (match v with | .lit value => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "literal")), (Prod.mk (α := String) (β := String) "literal" (LexLeanExtract.literal value))] : List (Prod String String)))) | .erased => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "erased"))] : List (Prod String String)))) | .proj typeName position struct => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "projection")), (Prod.mk (α := String) (β := String) "type_name" (LexLeanExtract.name typeName)), (Prod.mk (α := String) (β := String) "index" (ToString.toString (α := Nat) position)), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.fvar struct))] : List (Prod String String)))) | .const declName us args => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "const")), (Prod.mk (α := String) (β := String) "name" (LexLeanExtract.name declName)), (Prod.mk (α := String) (β := String) "levels" (LexLeanExtract.arr (List.map (α := Lean.Level) (β := String) (fun (u : Lean.Level) => (LexLeanExtract.str (ToString.toString (α := Lean.Level) u))) us))), (Prod.mk (α := String) (β := String) "arguments" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.arg a)) (Array.toList (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) args))))] : List (Prod String String)))) | .fvar id args => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "apply")), (Prod.mk (α := String) (β := String) "function" (LexLeanExtract.fvar id)), (Prod.mk (α := String) (β := String) "arguments" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.arg a)) (Array.toList (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) args))))] : List (Prod String String))))) + +meta def LexLeanExtract.param (p : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) : String := + (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar (p).fvarId)), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type (p).type)), (Prod.mk (α := String) (β := String) "borrow" (LexLeanExtract.bool (p).borrow))] : List (Prod String String)))) + +mutual +meta partial def LexLeanExtract.code (c : (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure)) : String := + (match c with | .«let» decl k => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "let")), (Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar (decl).fvarId)), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type (decl).type)), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.letValue (decl).value)), (Prod.mk (α := String) (β := String) "body" (LexLeanExtract.code k))] : List (Prod String String)))) | .«fun» decl k => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "fun")), (Prod.mk (α := String) (β := String) "declaration" (LexLeanExtract.funDecl decl)), (Prod.mk (α := String) (β := String) "body" (LexLeanExtract.code k))] : List (Prod String String)))) | .jp decl k => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "join")), (Prod.mk (α := String) (β := String) "declaration" (LexLeanExtract.funDecl decl)), (Prod.mk (α := String) (β := String) "body" (LexLeanExtract.code k))] : List (Prod String String)))) | .jmp id args => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "jump")), (Prod.mk (α := String) (β := String) "target" (LexLeanExtract.fvar id)), (Prod.mk (α := String) (β := String) "arguments" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.arg a)) (Array.toList (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) args))))] : List (Prod String String)))) | .cases cs => (LexLeanExtract.cases cs) | .«return» id => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "return")), (Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar id))] : List (Prod String String)))) | .unreach t => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "unreachable")), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type t))] : List (Prod String String))))) + +meta partial def LexLeanExtract.funDecl (d : (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure)) : String := + (match d with | .mk fvarId binderName params type value => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "id" (LexLeanExtract.fvar fvarId)), (Prod.mk (α := String) (β := String) "parameters" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (p : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.param p)) (Array.toList (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) params)))), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type type)), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.code value))] : List (Prod String String))))) + +meta partial def LexLeanExtract.cases (cs : (Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure)) : String := + (match cs with | .mk typeName resultType discr alts => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "cases")), (Prod.mk (α := String) (β := String) "type_name" (LexLeanExtract.name typeName)), (Prod.mk (α := String) (β := String) "result_type" (LexLeanExtract.type resultType)), (Prod.mk (α := String) (β := String) "discriminant" (LexLeanExtract.fvar discr)), (Prod.mk (α := String) (β := String) "alternatives" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (a : (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.alt a)) (Array.toList (α := (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) alts))))] : List (Prod String String))))) + +meta partial def LexLeanExtract.alt (a : (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) : String := + (match a with | .alt ctorName params k => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "constructor")), (Prod.mk (α := String) (β := String) "constructor" (LexLeanExtract.name ctorName)), (Prod.mk (α := String) (β := String) "parameters" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (p : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.param p)) (Array.toList (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) params)))), (Prod.mk (α := String) (β := String) "code" (LexLeanExtract.code k))] : List (Prod String String)))) | .default k => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "default")), (Prod.mk (α := String) (β := String) "code" (LexLeanExtract.code k))] : List (Prod String String))))) +end + +meta partial def LexLeanExtract.typeConstants (e : Lean.Expr) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match e with | .const n us => (if (Bool.or (BEq.beq (α := Lean.Name) n ``lcErased) (BEq.beq (α := Lean.Name) n ``lcAny)) then out else (LexLeanExtract.insert out n)) | .app f a => (LexLeanExtract.typeConstants a (LexLeanExtract.typeConstants f out)) | .forallE binderName d b binderInfo => (LexLeanExtract.typeConstants b (LexLeanExtract.typeConstants d out)) | .bvar position => out | .fvar id => out | .mvar id => out | .sort u => out | .lit literal => out | .lam binderName d b binderInfo => (LexLeanExtract.typeConstants b (LexLeanExtract.typeConstants d out)) | .letE declName t v b nonDep => (LexLeanExtract.typeConstants b (LexLeanExtract.typeConstants v (LexLeanExtract.typeConstants t out))) | .mdata data b => (LexLeanExtract.typeConstants b out) | .proj typeName idx b => (LexLeanExtract.typeConstants b (LexLeanExtract.insert out typeName))) + +meta def LexLeanExtract.argConstants (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match a with | .type e => (LexLeanExtract.typeConstants e out) | .erased => out | .fvar id => out) + +meta def LexLeanExtract.paramConstants (ps : (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (Array.foldl (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (p : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.typeConstants (p).type acc)) out ps) + +meta def LexLeanExtract.letValueConstants (v : (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match v with | .const n us args => (Array.foldl (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.argConstants a acc)) (LexLeanExtract.insert out n) args) | .fvar id args => (Array.foldl (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.argConstants a acc)) out args) | .proj typeName position struct => (LexLeanExtract.insert out typeName) | .lit value => out | .erased => out) + +mutual +meta partial def LexLeanExtract.codeConstants (c : (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match c with | .«let» decl k => (LexLeanExtract.codeConstants k (LexLeanExtract.letValueConstants (decl).value (LexLeanExtract.typeConstants (decl).type out))) | .«fun» decl k => (LexLeanExtract.codeConstants k (LexLeanExtract.funConstants decl out)) | .jp decl k => (LexLeanExtract.codeConstants k (LexLeanExtract.funConstants decl out)) | .jmp id args => (Array.foldl (α := (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (a : (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.argConstants a acc)) out args) | .cases cs => (LexLeanExtract.casesConstants cs out) | .«return» id => out | .unreach t => (LexLeanExtract.typeConstants t out)) + +meta partial def LexLeanExtract.funConstants (d : (Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match d with | .mk fvarId binderName params type value => (LexLeanExtract.codeConstants value (LexLeanExtract.typeConstants type (LexLeanExtract.paramConstants params out)))) + +meta partial def LexLeanExtract.casesConstants (cs : (Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match cs with | .mk typeName resultType discr alts => (Array.foldl (α := (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (a : (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.altConstants a acc)) (LexLeanExtract.typeConstants resultType (LexLeanExtract.insert out typeName)) alts)) + +meta partial def LexLeanExtract.altConstants (a : (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure)) (out : (Std.HashSet Lean.Name)) : (Std.HashSet Lean.Name) := + (match a with | .alt ctorName ps k => (LexLeanExtract.codeConstants k (LexLeanExtract.paramConstants ps (LexLeanExtract.insert out ctorName))) | .default k => (LexLeanExtract.codeConstants k out)) +end + +meta def LexLeanExtract.kind (info : Lean.ConstantInfo) : String := + (match info with | .defnInfo value => (match (value).safety with | .safe => "definition" | .«unsafe» => "unsafe-definition" | .«partial» => "partial-definition") | .opaqueInfo opaqueValue => "opaque" | .thmInfo theoremValue => "theorem" | .axiomInfo axiomValue => "axiom" | .inductInfo inductiveValue => "inductive" | .ctorInfo constructorValue => "constructor" | .recInfo recursorValue => "recursor" | .quotInfo quotientValue => "quotient") + +meta def LexLeanExtract.originalKind (env : Lean.Environment) (n : Lean.Name) : String := + (match (Lean.getOriginalConstKind? env n) with | .some original => (match original with | .defn => "definition" | .thm => "theorem" | .«axiom» => "axiom" | .«opaque» => "opaque" | .quot => "quotient" | .induct => "inductive" | .ctor => "constructor" | .recursor => "recursor") | .none => "unknown") + +meta def LexLeanExtract.moduleOf (env : Lean.Environment) (n : Lean.Name) : Lean.Name := + (match (Lean.Environment.getModuleIdxFor? env n) with | .some index => (Array.getD (α := Lean.Name) (Lean.EnvironmentHeader.moduleNames (Lean.Environment.header env)) index (Lean.Name.anonymous)) | .none => (Lean.Name.anonymous)) + +meta def LexLeanExtract.inProject (env : Lean.Environment) (modules : (Array Lean.Name)) (n : Lean.Name) : Bool := + (Array.contains (α := Lean.Name) modules (LexLeanExtract.moduleOf env n)) + +meta def LexLeanExtract.facts (env : Lean.Environment) (n : Lean.Name) (info : Lean.ConstantInfo) : (Lean.Core.CoreM (List (Prod String String))) := + (Bind.bind (m := Lean.Core.CoreM) (α := Bool) (β := (List (Prod String String))) (Lean.Compiler.LCNF.shouldGenerateCode n) (fun (generates : Bool) => (Pure.pure (f := Lean.Core.CoreM) (α := (List (Prod String String))) (([(Prod.mk (α := String) (β := String) "name" (LexLeanExtract.name n)), (Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str (LexLeanExtract.kind info))), (Prod.mk (α := String) (β := String) "module" (LexLeanExtract.name (LexLeanExtract.moduleOf env n))), (Prod.mk (α := String) (β := String) "computable" (LexLeanExtract.bool (Bool.not (Lean.isNoncomputable env n)))), (Prod.mk (α := String) (β := String) "generates_code" (LexLeanExtract.bool generates)), (Prod.mk (α := String) (β := String) "original_kind" (LexLeanExtract.str (LexLeanExtract.originalKind env n))), (Prod.mk (α := String) (β := String) "internal" (LexLeanExtract.bool (Lean.Name.isInternal n)))] : List (Prod String String)))))) + +mutual +meta partial def LexLeanExtract.sameSignature (a : Lean.Expr) (b : Lean.Expr) : Bool := + (match a with | .mdata data1 inner1 => (LexLeanExtract.sameSignature inner1 b) | _ => (match b with | .mdata data2 inner2 => (LexLeanExtract.sameSignature a inner2) | _ => (LexLeanExtract.sameStructure a b))) + +meta partial def LexLeanExtract.sameStructure (a : Lean.Expr) (b : Lean.Expr) : Bool := + (match a with | .forallE name1 domain1 body1 info1 => (match b with | .forallE name2 domain2 body2 info2 => (Bool.and (BEq.beq (α := Lean.BinderInfo) info1 info2) (Bool.and (LexLeanExtract.sameSignature domain1 domain2) (LexLeanExtract.sameSignature body1 body2))) | _ => (Bool.false)) | .lam name1 domain1 body1 info1 => (match b with | .lam name2 domain2 body2 info2 => (Bool.and (BEq.beq (α := Lean.BinderInfo) info1 info2) (Bool.and (LexLeanExtract.sameSignature domain1 domain2) (LexLeanExtract.sameSignature body1 body2))) | _ => (Bool.false)) | .app function1 argument1 => (match b with | .app function2 argument2 => (Bool.and (LexLeanExtract.sameSignature function1 function2) (LexLeanExtract.sameSignature argument1 argument2)) | _ => (Bool.false)) | .const constant1 levels1 => (match b with | .const constant2 levels2 => (Bool.and (BEq.beq (α := Lean.Name) constant1 constant2) (BEq.beq (α := (List Lean.Level)) levels1 levels2)) | _ => (Bool.false)) | .sort level1 => (match b with | .sort level2 => (BEq.beq (α := Lean.Level) level1 level2) | _ => (Bool.false)) | .bvar position1 => (match b with | .bvar position2 => (BEq.beq (α := Nat) position1 position2) | _ => (Bool.false)) | .lit literal1 => (match b with | .lit literal2 => (BEq.beq (α := Lean.Literal) literal1 literal2) | _ => (Bool.false)) | .fvar free1 => (match b with | .fvar free2 => (BEq.beq (α := Lean.FVarId) free1 free2) | _ => (Bool.false)) | .mvar meta1 => (match b with | .mvar meta2 => (BEq.beq (α := Lean.MVarId) meta1 meta2) | _ => (Bool.false)) | .letE local1 type1 value1 scope1 flag1 => (match b with | .letE local2 type2 value2 scope2 flag2 => (Bool.and (LexLeanExtract.sameSignature type1 type2) (Bool.and (LexLeanExtract.sameSignature value1 value2) (LexLeanExtract.sameSignature scope1 scope2))) | _ => (Bool.false)) | .proj structure1 field1 target1 => (match b with | .proj structure2 field2 target2 => (Bool.and (BEq.beq (α := Lean.Name) structure1 structure2) (Bool.and (BEq.beq (α := Nat) field1 field2) (LexLeanExtract.sameSignature target1 target2))) | _ => (Bool.false)) | _ => (Bool.false)) +end + +public meta def LexLeanExtract.elabSignature : Lean.Elab.Command.CommandElab := + (fun (stx : Lean.Syntax) => (Lean.Elab.Command.liftTermElabM (α := Unit) (let declName : Lean.Name := (Lean.Syntax.getId (Lean.Syntax.getArg stx 1)); (Bind.bind (m := Lean.Elab.Term.TermElabM) (α := Lean.ConstantInfo) (β := Unit) (Lean.getConstInfo (m := Lean.Elab.Term.TermElabM) declName) (fun (info : Lean.ConstantInfo) => (Bind.bind (m := Lean.Elab.Term.TermElabM) (α := Lean.Expr) (β := Unit) (Lean.Elab.Term.elabType (Lean.Syntax.getArg stx 3)) (fun (elaborated : Lean.Expr) => (Bind.bind (m := Lean.Elab.Term.TermElabM) (α := Lean.Expr) (β := Unit) (Lean.instantiateMVars (m := Lean.Elab.Term.TermElabM) elaborated) (fun (registered : Lean.Expr) => (Bind.bind (m := Lean.Elab.Term.TermElabM) (α := Lean.Expr) (β := Unit) (Lean.instantiateMVars (m := Lean.Elab.Term.TermElabM) (Lean.ConstantInfo.type info)) (fun (actual : Lean.Expr) => (if (LexLeanExtract.sameSignature actual registered) then (Pure.pure (f := Lean.Elab.Term.TermElabM) (α := Unit) (Unit.unit)) else (Lean.«throwError» (m := Lean.Elab.Term.TermElabM) (α := Unit) (Lean.MessageData.compose (Lean.stringToMessageData "lexlean-extract-drift: the signature of `") (Lean.MessageData.compose (Lean.MessageData.ofName declName) (Lean.MessageData.compose (Lean.stringToMessageData "` is ") (Lean.MessageData.ofExpr (Lean.ConstantInfo.type info)))))))))))))))))) + +meta def LexLeanExtract.classify (env : Lean.Environment) (c : Lean.Name) (info : Lean.ConstantInfo) : String := + (let structural : Bool := (Bool.or (Lean.Environment.isProjectionFn env c) (Bool.or (Lean.isCasesOnRecursor env c) (Bool.or (Lean.isAuxRecursor env c) (Bool.or (Lean.isNoConfusion env c) (Bool.or (Lean.Name.isInternal c) (Bool.or (Lean.Meta.isInstanceCore env c) (Bool.or (Lean.Meta.isMatcherCore env c) (BEq.beq (α := String) (Lean.Name.getString! c) "ctorIdx")))))))); (let former : Bool := (Lean.Expr.isSort (Lean.Expr.getForallBody (Lean.ConstantInfo.type info))); (match info with | .inductInfo inductiveValue => "type" | .defnInfo definitionValue => (if former then "type" else (if (Bool.and (Lean.Name.isPrefixOf (Lean.Name.mkSimple "Lean") c) (Bool.not structural)) then "call" else "plumbing")) | .opaqueInfo opaqueValue => (if (Bool.and (Lean.Name.isPrefixOf (Lean.Name.mkSimple "Lean") c) (Bool.not structural)) then "call" else "plumbing") | .axiomInfo axiomValue => (if (Bool.and (Bool.and (Lean.Name.isPrefixOf (Lean.Name.mkSimple "Lean") c) (Bool.not structural)) (Bool.not former)) then "call" else "plumbing") | .thmInfo theoremValue => "plumbing" | .quotInfo quotientValue => "plumbing" | .ctorInfo constructorValue => "plumbing" | .recInfo recursorValue => "plumbing"))) + +meta def LexLeanExtract.ownNames (env : Lean.Environment) : (Std.HashSet Lean.Name) := + (Lean.SMap.foldStage2 (α := Lean.Name) (β := Lean.ConstantInfo) (σ := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (n : Lean.Name) (info : Lean.ConstantInfo) => (LexLeanExtract.insert acc n)) (Std.HashSet.emptyWithCapacity (α := Lean.Name)) (Lean.Environment.constants env)) + +meta def LexLeanExtract.ownUses (env : Lean.Environment) : (Std.HashSet Lean.Name) := + (Lean.SMap.foldStage2 (α := Lean.Name) (β := Lean.ConstantInfo) (σ := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (n : Lean.Name) (info : Lean.ConstantInfo) => (if (List.elem (α := Lean.Name) (Lean.Name.mkSimple "LexLeanExtract") (Lean.Name.components (Lean.Name.eraseMacroScopes n))) then (Array.foldl (α := Lean.Name) (β := (Std.HashSet Lean.Name)) (fun (seen : (Std.HashSet Lean.Name)) (used : Lean.Name) => (LexLeanExtract.insert seen used)) (Array.foldl (α := Lean.Name) (β := (Std.HashSet Lean.Name)) (fun (seen : (Std.HashSet Lean.Name)) (used : Lean.Name) => (LexLeanExtract.insert seen used)) acc (Lean.Expr.getUsedConstants (Lean.ConstantInfo.type info))) (match (Lean.ConstantInfo.value? info (Bool.true)) with | .some value => (Lean.Expr.getUsedConstants value) | .none => ((#[] : Array Lean.Name)))) else acc)) (Std.HashSet.emptyWithCapacity (α := Lean.Name)) (Lean.Environment.constants env)) + +meta partial def LexLeanExtract.classifyAll (env : Lean.Environment) (own : (Std.HashSet Lean.Name)) (names : (List Lean.Name)) : (Lean.Elab.Command.CommandElabM (List (Prod Lean.Name String))) := + (match names with | .nil => (Pure.pure (f := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (List.nil (α := (Prod Lean.Name String)))) | .cons c rest => (if (Std.HashSet.contains (α := Lean.Name) own c) then (LexLeanExtract.classifyAll env own rest) else (match (Lean.Environment.find? env c) with | .some info => (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (β := (List (Prod Lean.Name String))) (LexLeanExtract.classifyAll env own rest) (fun (tail : (List (Prod Lean.Name String))) => (Pure.pure (f := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (List.cons (α := (Prod Lean.Name String)) (Prod.mk (α := Lean.Name) (β := String) c (LexLeanExtract.classify env c info)) tail)))) | .none => (Lean.«throwError» (m := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (Lean.stringToMessageData (String.append "lexlean-extract-drift: the adapter uses the unknown constant `" (String.append (Lean.Name.toString c) "`"))))))) + +meta def LexLeanExtract.adapterConstants : (Lean.Elab.Command.CommandElabM (List (Prod Lean.Name String))) := + (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := Lean.Environment) (β := (List (Prod Lean.Name String))) (Lean.MonadEnv.getEnv (m := Lean.Elab.Command.CommandElabM)) (fun (env : Lean.Environment) => (LexLeanExtract.classifyAll env (LexLeanExtract.ownNames env) (LexLeanExtract.sorted (LexLeanExtract.ownUses env))))) + +meta partial def LexLeanExtract.listLines (used : (List (Prod Lean.Name String))) : (Lean.Elab.Command.CommandElabM Unit) := + (match used with | .nil => (Pure.pure (f := Lean.Elab.Command.CommandElabM) (α := Unit) (Unit.unit)) | .cons entry rest => (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := Unit) (β := Unit) (MonadLiftT.monadLift (m := IO) (n := Lean.Elab.Command.CommandElabM) (α := Unit) (IO.println (α := String) (String.append (entry).snd (String.append " " (Lean.Name.toString (entry).fst))))) (fun (printed : Unit) => (LexLeanExtract.listLines rest)))) + +meta def LexLeanExtract.listAdapterConstants : (Lean.Elab.Command.CommandElabM Unit) := + (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (β := Unit) (LexLeanExtract.adapterConstants) (fun (used : (List (Prod Lean.Name String))) => (LexLeanExtract.listLines used))) + +meta def LexLeanExtract.registeredClass (calls : (Array Lean.Name)) (types : (Array (Prod Lean.Name (Array String)))) (opaques : (Array Lean.Name)) (plumbing : (Array Lean.Name)) (c : Lean.Name) : String := + (let typeNames : (List Lean.Name) := (List.map (α := (Prod Lean.Name (Array String))) (β := Lean.Name) (fun (row : (Prod Lean.Name (Array String))) => (row).fst) (Array.toList (α := (Prod Lean.Name (Array String))) types)); (if (Array.contains (α := Lean.Name) calls c) then "call" else (if (Bool.or (List.contains (α := Lean.Name) typeNames c) (Array.contains (α := Lean.Name) opaques c)) then "type" else (if (Array.contains (α := Lean.Name) plumbing c) then "plumbing" else (if (List.any (α := (Prod Lean.Name (Array String))) (Array.toList (α := (Prod Lean.Name (Array String))) types) (fun (candidate : (Prod Lean.Name (Array String))) => (Bool.and (BEq.beq (α := Lean.Name) (Lean.Name.getPrefix c) (candidate).fst) (Array.contains (α := String) (candidate).snd (Lean.Name.getString! c))))) then "plumbing" else "unregistered"))))) + +meta partial def LexLeanExtract.usedProblems (calls : (Array Lean.Name)) (types : (Array (Prod Lean.Name (Array String)))) (opaques : (Array Lean.Name)) (plumbing : (Array Lean.Name)) (used : (List (Prod Lean.Name String))) : (List String) := + (match used with | .nil => (List.nil (α := String)) | .cons entry rest => (let c : Lean.Name := (entry).fst; (let foreignType : Bool := (Bool.and (BEq.beq (α := String) (entry).snd "type") (Bool.not (Lean.Name.isPrefixOf (Lean.Name.mkSimple "Lean") c))); (let expected : String := (if foreignType then "a type or plumbing" else (entry).snd); (let registered : String := (LexLeanExtract.registeredClass calls types opaques plumbing c); (if (if (BEq.beq (α := String) (entry).snd "plumbing") then (Bool.not (BEq.beq (α := String) registered "unregistered")) else (if foreignType then (Bool.or (BEq.beq (α := String) registered "type") (BEq.beq (α := String) registered "plumbing")) else (BEq.beq (α := String) registered expected))) then (LexLeanExtract.usedProblems calls types opaques plumbing rest) else (List.cons (α := String) (String.append "`" (String.append (Lean.Name.toString c) (String.append "` is used as " (String.append expected (String.append " but registered as " registered))))) (LexLeanExtract.usedProblems calls types opaques plumbing rest)))))))) + +meta partial def LexLeanExtract.unusedProblems (used : (List (Prod Lean.Name String))) (names : (List Lean.Name)) : (List String) := + (match names with | .nil => (List.nil (α := String)) | .cons c rest => (if (List.any (α := (Prod Lean.Name String)) used (fun (entry : (Prod Lean.Name String)) => (BEq.beq (α := Lean.Name) (entry).fst c))) then (LexLeanExtract.unusedProblems used rest) else (List.cons (α := String) (String.append "`" (String.append (Lean.Name.toString c) "` is plumbing but unused")) (LexLeanExtract.unusedProblems used rest)))) + +meta partial def LexLeanExtract.typeProblems (env : Lean.Environment) (types : (List (Prod Lean.Name (Array String)))) : (List String) := + (match types with | .nil => (List.nil (α := String)) | .cons row rest => (let n : Lean.Name := (row).fst; (match (Lean.Environment.find? env n) with | .some info => (match info with | .inductInfo «inductive» => (if (BEq.beq (α := (List String)) (List.map (α := Lean.Name) (β := String) (fun (constructorName : Lean.Name) => (Lean.Name.getString! constructorName)) («inductive»).ctors) (Array.toList (α := String) (row).snd)) then (LexLeanExtract.typeProblems env rest) else (List.cons (α := String) (String.append "`" (String.append (Lean.Name.toString n) (String.append "` has constructors " (String.append (ToString.toString (α := (List String)) (List.map (α := Lean.Name) (β := String) (fun (listed : Lean.Name) => (Lean.Name.getString! listed)) («inductive»).ctors)) (String.append ", registered " (ToString.toString (α := (List String)) (Array.toList (α := String) (row).snd))))))) (LexLeanExtract.typeProblems env rest))) | _ => (if (Array.isEmpty (α := String) (row).snd) then (LexLeanExtract.typeProblems env rest) else (List.cons (α := String) (String.append "`" (String.append (Lean.Name.toString n) (String.append "` is not an inductive type, registered with constructors " (ToString.toString (α := (List String)) (Array.toList (α := String) (row).snd))))) (LexLeanExtract.typeProblems env rest)))) | .none => (List.cons (α := String) (String.append "`" (String.append (Lean.Name.toString n) "` is not a constant")) (LexLeanExtract.typeProblems env rest))))) + +meta def LexLeanExtract.checkNames (calls : (Array Lean.Name)) (types : (Array (Prod Lean.Name (Array String)))) (opaques : (Array Lean.Name)) (plumbing : (Array Lean.Name)) : (Lean.Elab.Command.CommandElabM Unit) := + (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := Lean.Environment) (β := Unit) (Lean.MonadEnv.getEnv (m := Lean.Elab.Command.CommandElabM)) (fun (env : Lean.Environment) => (Bind.bind (m := Lean.Elab.Command.CommandElabM) (α := (List (Prod Lean.Name String))) (β := Unit) (LexLeanExtract.adapterConstants) (fun (used : (List (Prod Lean.Name String))) => (let names : (List Lean.Name) := (Array.toList (α := Lean.Name) plumbing); (let differences : (List String) := (List.append (α := String) (LexLeanExtract.usedProblems calls types opaques plumbing used) (List.append (α := String) (LexLeanExtract.unusedProblems used names) (LexLeanExtract.typeProblems env (Array.toList (α := (Prod Lean.Name (Array String))) types)))); (if (List.isEmpty (α := String) differences) then (Pure.pure (f := Lean.Elab.Command.CommandElabM) (α := Unit) (Unit.unit)) else (Lean.«throwError» (m := Lean.Elab.Command.CommandElabM) (α := Unit) (Lean.stringToMessageData (String.append "lexlean-extract-drift: the adapter and its registry differ: " (String.intercalate "; " differences))))))))))) + +meta def LexLeanExtract.declUses (decl : (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) : (Std.HashSet Lean.Name) := + (match (decl).value with | .code body => (LexLeanExtract.codeConstants body (LexLeanExtract.typeConstants ((decl).toSignature).type (LexLeanExtract.paramConstants ((decl).toSignature).params (Std.HashSet.emptyWithCapacity (α := Lean.Name))))) | .extern attributes => (LexLeanExtract.typeConstants ((decl).toSignature).type (LexLeanExtract.paramConstants ((decl).toSignature).params (Std.HashSet.emptyWithCapacity (α := Lean.Name))))) + +meta def LexLeanExtract.declText (decl : (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) : String := + (let signatureUses : (Std.HashSet Lean.Name) := (LexLeanExtract.typeConstants ((decl).toSignature).type (LexLeanExtract.paramConstants ((decl).toSignature).params (Std.HashSet.emptyWithCapacity (α := Lean.Name)))); (match (decl).value with | .code body => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "safe" (LexLeanExtract.bool ((decl).toSignature).safe)), (Prod.mk (α := String) (β := String) "level_parameters" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (levelName : Lean.Name) => (LexLeanExtract.name levelName)) ((decl).toSignature).levelParams))), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type ((decl).toSignature).type)), (Prod.mk (α := String) (β := String) "parameters" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (parameter : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.param parameter)) (Array.toList (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) ((decl).toSignature).params)))), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "code")), (Prod.mk (α := String) (β := String) "code" (LexLeanExtract.code body))] : List (Prod String String))))), (Prod.mk (α := String) (β := String) "uses" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (usedName : Lean.Name) => (LexLeanExtract.name usedName)) (LexLeanExtract.sorted (LexLeanExtract.codeConstants body signatureUses)))))] : List (Prod String String)))) | .extern attributes => (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "safe" (LexLeanExtract.bool ((decl).toSignature).safe)), (Prod.mk (α := String) (β := String) "level_parameters" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (levelName : Lean.Name) => (LexLeanExtract.name levelName)) ((decl).toSignature).levelParams))), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type ((decl).toSignature).type)), (Prod.mk (α := String) (β := String) "parameters" (LexLeanExtract.arr (List.map (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) (β := String) (fun (parameter : (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) => (LexLeanExtract.param parameter)) (Array.toList (α := (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) ((decl).toSignature).params)))), (Prod.mk (α := String) (β := String) "value" (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "kind" (LexLeanExtract.str "extern"))] : List (Prod String String))))), (Prod.mk (α := String) (β := String) "uses" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (usedName : Lean.Name) => (LexLeanExtract.name usedName)) (LexLeanExtract.sorted signatureUses))))] : List (Prod String String)))))) + +meta partial def LexLeanExtract.codeLoop (env : Lean.Environment) (modules : (Array Lean.Name)) (queue : (List Lean.Name)) (visited : (Std.HashSet Lean.Name)) (decls : (Std.HashMap Lean.Name String)) (referenced : (Std.HashSet Lean.Name)) : (Lean.Core.CoreM (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) := + (match queue with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (Prod.mk (α := (Std.HashSet Lean.Name)) (β := (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name))) visited (Prod.mk (α := (Std.HashMap Lean.Name String)) (β := (Std.HashSet Lean.Name)) decls referenced))) | .cons n rest => (if (Std.HashSet.contains (α := Lean.Name) visited n) then (LexLeanExtract.codeLoop env modules rest visited decls referenced) else (match (Lean.Environment.find? env n) with | .some info => (let visitedNow : (Std.HashSet Lean.Name) := (LexLeanExtract.insert visited n); (if (Bool.and (BEq.beq (α := String) (LexLeanExtract.kind info) "definition") (Bool.not (Lean.isNoncomputable env n))) then (Bind.bind (m := Lean.Core.CoreM) (α := Bool) (β := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (Lean.Compiler.LCNF.shouldGenerateCode n) (fun (generates : Bool) => (if generates then (Bind.bind (m := Lean.Core.CoreM) (α := Unit) (β := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (Lean.MonadNameGenerator.setNGen (m := Lean.Core.CoreM) (Lean.NameGenerator.mk (Lean.Name.mkSimple "_uniq") 1)) (fun (restarted : Unit) => (Bind.bind (m := Lean.Core.CoreM) (α := (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) (β := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (Lean.Compiler.LCNF.CompilerM.run (α := (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) (Lean.Compiler.LCNF.toDecl n)) (fun (decl : (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) => (let uses : (List Lean.Name) := (LexLeanExtract.sorted (LexLeanExtract.declUses decl)); (LexLeanExtract.codeLoop env modules (List.append (α := Lean.Name) rest (List.filter (α := Lean.Name) (fun (candidate : Lean.Name) => (LexLeanExtract.inProject env modules candidate)) uses)) visitedNow (Std.HashMap.insert (α := Lean.Name) (β := String) decls ((decl).toSignature).name (LexLeanExtract.declText decl)) (List.foldl (α := (Std.HashSet Lean.Name)) (β := Lean.Name) (fun (seen : (Std.HashSet Lean.Name)) (outside : Lean.Name) => (LexLeanExtract.insert seen outside)) referenced (List.filter (α := Lean.Name) (fun (outside : Lean.Name) => (Bool.not (LexLeanExtract.inProject env modules outside))) uses)))))))) else (LexLeanExtract.codeLoop env modules rest visitedNow decls referenced)))) else (LexLeanExtract.codeLoop env modules rest visitedNow decls referenced))) | .none => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (Lean.stringToMessageData (String.append "lexlean-extract: unresolved constant `" (String.append (Lean.Name.toString n) "`"))))))) + +meta partial def LexLeanExtract.kernelLoop (env : Lean.Environment) (modules : (Array Lean.Name)) (queue : (List Lean.Name)) (seen : (Std.HashSet Lean.Name)) : (Lean.Core.CoreM (Std.HashSet Lean.Name)) := + (match queue with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := (Std.HashSet Lean.Name)) seen) | .cons n rest => (if (Std.HashSet.contains (α := Lean.Name) seen n) then (LexLeanExtract.kernelLoop env modules rest seen) else (match (Lean.Environment.find? env n) with | .some info => (LexLeanExtract.kernelLoop env modules (List.append (α := Lean.Name) rest (List.filter (α := Lean.Name) (fun (candidate : Lean.Name) => (LexLeanExtract.inProject env modules candidate)) (LexLeanExtract.sorted (Array.foldl (α := Lean.Name) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (used : Lean.Name) => (LexLeanExtract.insert acc used)) (Std.HashSet.emptyWithCapacity (α := Lean.Name)) (match (Lean.ConstantInfo.value? info (Bool.true)) with | .some value => (Lean.Expr.getUsedConstants value) | .none => ((#[] : Array Lean.Name))))))) (LexLeanExtract.insert seen n)) | .none => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (Std.HashSet Lean.Name)) (Lean.stringToMessageData (String.append "lexlean-extract: unresolved constant `" (String.append (Lean.Name.toString n) "`"))))))) + +meta partial def LexLeanExtract.ctorRows (env : Lean.Environment) (names : (List Lean.Name)) : (Lean.Core.CoreM (List String)) := + (match names with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.nil (α := String))) | .cons c rest => (match (Lean.Environment.find? env c) with | .some info => (match info with | .ctorInfo constructor => (Bind.bind (m := Lean.Core.CoreM) (α := Lean.Expr) (β := (List String)) (Lean.Meta.MetaM.run' (α := Lean.Expr) (Lean.Compiler.LCNF.toLCNFType ((constructor).toConstantVal).type)) (fun (constructorType : Lean.Expr) => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := (List String)) (LexLeanExtract.ctorRows env rest) (fun (tail : (List String)) => (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.cons (α := String) (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "name" (LexLeanExtract.name c)), (Prod.mk (α := String) (β := String) "parameters" (ToString.toString (α := Nat) (constructor).numParams)), (Prod.mk (α := String) (β := String) "fields" (ToString.toString (α := Nat) (constructor).numFields)), (Prod.mk (α := String) (β := String) "type" (LexLeanExtract.type constructorType))] : List (Prod String String)))) tail)))))) | _ => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (List String)) (Lean.stringToMessageData (String.append "lexlean-extract: `" (String.append (Lean.Name.toString c) "` is not a constructor"))))) | .none => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (List String)) (Lean.stringToMessageData (String.append "lexlean-extract: `" (String.append (Lean.Name.toString c) "` is not a constructor")))))) + +meta def LexLeanExtract.inductiveRow (env : Lean.Environment) (n : Lean.Name) : (Lean.Core.CoreM String) := + (match (Lean.Environment.find? env n) with | .some info => (match info with | .inductInfo «inductive» => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := String) (LexLeanExtract.ctorRows env («inductive»).ctors) (fun (constructors : (List String)) => (Pure.pure (f := Lean.Core.CoreM) (α := String) (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "parameters" (ToString.toString (α := Nat) («inductive»).numParams)), (Prod.mk (α := String) (β := String) "indices" (ToString.toString (α := Nat) («inductive»).numIndices)), (Prod.mk (α := String) (β := String) "recursive" (LexLeanExtract.bool («inductive»).isRec)), (Prod.mk (α := String) (β := String) "constructors" (LexLeanExtract.arr constructors))] : List (Prod String String))))))) | _ => (Pure.pure (f := Lean.Core.CoreM) (α := String) "null")) | .none => (Pure.pure (f := Lean.Core.CoreM) (α := String) "null")) + +meta partial def LexLeanExtract.constantRows (env : Lean.Environment) (decls : (Std.HashMap Lean.Name String)) (names : (List Lean.Name)) : (Lean.Core.CoreM (List String)) := + (match names with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.nil (α := String))) | .cons n rest => (match (Lean.Environment.find? env n) with | .some info => (Bind.bind (m := Lean.Core.CoreM) (α := (List (Prod String String))) (β := (List String)) (LexLeanExtract.facts env n info) (fun (row : (List (Prod String String))) => (Bind.bind (m := Lean.Core.CoreM) (α := String) (β := (List String)) (LexLeanExtract.inductiveRow env n) (fun (inductiveText : String) => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := (List String)) (LexLeanExtract.constantRows env decls rest) (fun (tail : (List String)) => (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.cons (α := String) (LexLeanExtract.obj (List.append (α := (Prod String String)) row (([(Prod.mk (α := String) (β := String) "kernel_uses" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (usedName : Lean.Name) => (LexLeanExtract.name usedName)) (LexLeanExtract.sorted (Array.foldl (α := Lean.Name) (β := (Std.HashSet Lean.Name)) (fun (acc : (Std.HashSet Lean.Name)) (used : Lean.Name) => (LexLeanExtract.insert acc used)) (Std.HashSet.emptyWithCapacity (α := Lean.Name)) (match (Lean.ConstantInfo.value? info (Bool.true)) with | .some value => (Lean.Expr.getUsedConstants value) | .none => ((#[] : Array Lean.Name)))))))), (Prod.mk (α := String) (β := String) "declaration" (Option.getD (α := String) (Std.HashMap.get? (α := Lean.Name) (β := String) decls n) "null")), (Prod.mk (α := String) (β := String) "inductive" inductiveText)] : List (Prod String String))))) tail)))))))) | .none => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (List String)) (Lean.stringToMessageData (String.append "lexlean-extract: unresolved constant `" (String.append (Lean.Name.toString n) "`")))))) + +meta partial def LexLeanExtract.externalRows (env : Lean.Environment) (names : (List Lean.Name)) : (Lean.Core.CoreM (List String)) := + (match names with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.nil (α := String))) | .cons r rest => (match (Lean.Environment.find? env r) with | .some info => (Bind.bind (m := Lean.Core.CoreM) (α := (List (Prod String String))) (β := (List String)) (LexLeanExtract.facts env r info) (fun (row : (List (Prod String String))) => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := (List String)) (LexLeanExtract.externalRows env rest) (fun (tail : (List String)) => (let compiled : (Prod String String) := (Prod.mk (α := String) (β := String) "compiled" (LexLeanExtract.bool (Option.isSome (α := Lean.IR.Decl) (Lean.IR.findEnvDecl env r)))); (Pure.pure (f := Lean.Core.CoreM) (α := (List String)) (List.cons (α := String) (LexLeanExtract.obj (List.append (α := (Prod String String)) row (match info with | .ctorInfo constructor => (([compiled, (Prod.mk (α := String) (β := String) "inductive_type" (LexLeanExtract.name (constructor).induct))] : List (Prod String String))) | _ => (([compiled] : List (Prod String String)))))) tail))))))) | .none => (Lean.«throwError» (m := Lean.Core.CoreM) (α := (List String)) (Lean.stringToMessageData (String.append "lexlean-extract: unresolved constant `" (String.append (Lean.Name.toString r) "`")))))) + +meta partial def LexLeanExtract.checkRoots (env : Lean.Environment) (modules : (Array Lean.Name)) (roots : (List Lean.Name)) : (Lean.Core.CoreM Unit) := + (match roots with | .nil => (Pure.pure (f := Lean.Core.CoreM) (α := Unit) (Unit.unit)) | .cons root rest => (if (Bool.and (LexLeanExtract.inProject env modules root) (Option.isSome (α := Lean.ConstantInfo) (Lean.Environment.find? env root))) then (LexLeanExtract.checkRoots env modules rest) else (Lean.«throwError» (m := Lean.Core.CoreM) (α := Unit) (Lean.stringToMessageData (String.append "lexlean-extract: unknown root `" (String.append (Lean.Name.toString root) "`")))))) + +meta def LexLeanExtract.run (roots : (Array Lean.Name)) (modules : (Array Lean.Name)) : (Lean.Core.CoreM String) := + (Bind.bind (m := Lean.Core.CoreM) (α := Lean.Environment) (β := String) (Lean.MonadEnv.getEnv (m := Lean.Core.CoreM)) (fun (env : Lean.Environment) => (Bind.bind (m := Lean.Core.CoreM) (α := Unit) (β := String) (LexLeanExtract.checkRoots env modules (Array.toList (α := Lean.Name) roots)) (fun (checked : Unit) => (Bind.bind (m := Lean.Core.CoreM) (α := (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) (β := String) (LexLeanExtract.codeLoop env modules (Array.toList (α := Lean.Name) roots) (Std.HashSet.emptyWithCapacity (α := Lean.Name)) (Std.HashMap.emptyWithCapacity (α := Lean.Name) (β := String)) (Std.HashSet.emptyWithCapacity (α := Lean.Name))) (fun (visit : (Prod (Std.HashSet Lean.Name) (Prod (Std.HashMap Lean.Name String) (Std.HashSet Lean.Name)))) => (Bind.bind (m := Lean.Core.CoreM) (α := (Std.HashSet Lean.Name)) (β := String) (LexLeanExtract.kernelLoop env modules (Std.HashSet.toList (α := Lean.Name) (visit).fst) (Std.HashSet.emptyWithCapacity (α := Lean.Name))) (fun (recorded : (Std.HashSet Lean.Name)) => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := String) (LexLeanExtract.constantRows env ((visit).snd).fst (LexLeanExtract.sorted recorded)) (fun (constants : (List String)) => (Bind.bind (m := Lean.Core.CoreM) (α := (List String)) (β := String) (LexLeanExtract.externalRows env (LexLeanExtract.sorted ((visit).snd).snd)) (fun (externals : (List String)) => (Pure.pure (f := Lean.Core.CoreM) (α := String) (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "spec" (LexLeanExtract.str "lexlean/lcnf-extraction/2")), (Prod.mk (α := String) (β := String) "lean" (LexLeanExtract.obj (([(Prod.mk (α := String) (β := String) "version" (LexLeanExtract.str (Lean.versionString))), (Prod.mk (α := String) (β := String) "githash" (LexLeanExtract.str (Lean.githash)))] : List (Prod String String))))), (Prod.mk (α := String) (β := String) "roots" (LexLeanExtract.arr (List.map (α := Lean.Name) (β := String) (fun (listedName : Lean.Name) => (LexLeanExtract.name listedName)) (Array.toList (α := Lean.Name) roots)))), (Prod.mk (α := String) (β := String) "constants" (LexLeanExtract.arr constants)), (Prod.mk (α := String) (β := String) "externals" (LexLeanExtract.arr externals))] : List (Prod String String))))))))))))))))) + +meta def LexLeanExtract.mainNames (roots : (Array Lean.Name)) (modules : (Array Lean.Name)) : (Lean.Elab.Command.CommandElabM Unit) := + (Lean.Elab.Command.liftCoreM (α := Unit) (Bind.bind (m := Lean.Core.CoreM) (α := String) (β := Unit) (LexLeanExtract.run roots modules) (fun (text : String) => (MonadLiftT.monadLift (m := IO) (n := Lean.Core.CoreM) (α := Unit) (IO.println (α := String) text))))) + +meta def LexLeanExtract.toNames (texts : (Array String)) : (Array Lean.Name) := + (Array.map (α := String) (β := Lean.Name) (fun (text : String) => (String.toName text)) texts) + +meta def LexLeanExtract.toTypeRows (rows : (Array (Prod String (Array String)))) : (Array (Prod Lean.Name (Array String))) := + (Array.map (α := (Prod String (Array String))) (β := (Prod Lean.Name (Array String))) (fun (row : (Prod String (Array String))) => (Prod.mk (α := Lean.Name) (β := (Array String)) (String.toName (row).fst) (row).snd)) rows) + +meta def LexLeanExtract.checkAuthority (calls : (Array String)) (types : (Array (Prod String (Array String)))) (opaques : (Array String)) (plumbing : (Array String)) : (Lean.Elab.Command.CommandElabM Unit) := + (LexLeanExtract.checkNames (LexLeanExtract.toNames calls) (LexLeanExtract.toTypeRows types) (LexLeanExtract.toNames opaques) (LexLeanExtract.toNames plumbing)) + +meta def LexLeanExtract.main (roots : (Array String)) (modules : (Array String)) : (Lean.Elab.Command.CommandElabM Unit) := + (LexLeanExtract.mainNames (LexLeanExtract.toNames roots) (LexLeanExtract.toNames modules)) + +syntax (name := LexLeanExtract.signatureCommand) "lexlean_signature " ident " : " term : command +attribute [command_elab LexLeanExtract.signatureCommand] LexLeanExtract.elabSignature + +lexlean_signature Array.contains : ({α : (Type u)} → ([h1 : (BEq α)] → ((Array α) → (α → Bool)))) + +lexlean_signature Array.foldl : ({α : (Type u)} → ({β : (Type v)} → ((β → (α → β)) → (β → ((as : (Array α)) → ((optParam Nat 0) → ((optParam Nat (@Array.size α as)) → β))))))) + +lexlean_signature Array.getD : ({α : (Type u_1)} → ((Array α) → (Nat → (α → α)))) + +lexlean_signature Array.isEmpty : ({α : (Type u)} → ((Array α) → Bool)) + +lexlean_signature Array.map : ({α : (Type u)} → ({β : (Type v)} → ((α → β) → ((Array α) → (Array β))))) + +lexlean_signature Array.size : ({α : (Type u)} → ((Array α) → Nat)) + +lexlean_signature Array.toList : ({α : (Type u)} → ((Array α) → (List α))) + +lexlean_signature BEq.beq : ({α : (Type u)} → ([self : (BEq α)] → (α → (α → Bool)))) + +lexlean_signature Bind.bind : ({m : ((Type u) → (Type v))} → ([self : (Bind m)] → ({α : (Type u)} → ({β : (Type u)} → ((m α) → ((α → (m β)) → (m β))))))) + +lexlean_signature Bool.and : (Bool → (Bool → Bool)) + +lexlean_signature Bool.not : (Bool → Bool) + +lexlean_signature Bool.or : (Bool → (Bool → Bool)) + +lexlean_signature Char.toNat : (Char → Nat) + +lexlean_signature IO.println : ({α : (Type u_1)} → ([h1 : (ToString α)] → (α → (IO Unit)))) + +lexlean_signature Lean.Compiler.LCNF.CompilerM.run : ({α : Type} → ((Lean.Compiler.LCNF.CompilerM α) → ((optParam Lean.Compiler.LCNF.CompilerM.State { }) → ((optParam Lean.Compiler.LCNF.Phase Lean.Compiler.LCNF.Phase.base) → (Lean.Core.CoreM α))))) + +lexlean_signature Lean.Compiler.LCNF.shouldGenerateCode : (Lean.Name → (Lean.Core.CoreM Bool)) + +lexlean_signature Lean.Compiler.LCNF.toDecl : (Lean.Name → (Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure))) + +lexlean_signature Lean.Compiler.LCNF.toLCNFType : (Lean.Expr → (Lean.Meta.MetaM Lean.Expr)) + +lexlean_signature Lean.ConstantInfo.type : (Lean.ConstantInfo → Lean.Expr) + +lexlean_signature Lean.ConstantInfo.value? : (Lean.ConstantInfo → ((optParam Bool Bool.false) → (Option Lean.Expr))) + +lexlean_signature Lean.Elab.Command.liftCoreM : ({α : Type} → ((Lean.Core.CoreM α) → (Lean.Elab.Command.CommandElabM α))) + +lexlean_signature Lean.Elab.Command.liftTermElabM : ({α : Type} → ((Lean.Elab.Term.TermElabM α) → (Lean.Elab.Command.CommandElabM α))) + +lexlean_signature Lean.Elab.Term.elabType : (Lean.Syntax → (Lean.Elab.Term.TermElabM Lean.Expr)) + +lexlean_signature Lean.EnvExtension.asyncMode : ({σ : Type} → ((Lean.EnvExtension σ) → Lean.EnvExtension.AsyncMode)) + +lexlean_signature Lean.Environment.constants : (Lean.Environment → Lean.ConstMap) + +lexlean_signature Lean.Environment.find? : (Lean.Environment → (Lean.Name → ((optParam Bool Bool.false) → (Option Lean.ConstantInfo)))) + +lexlean_signature Lean.Environment.getModuleIdxFor? : (Lean.Environment → (Lean.Name → (Option Lean.ModuleIdx))) + +lexlean_signature Lean.Environment.header : (Lean.Environment → Lean.EnvironmentHeader) + +lexlean_signature Lean.Environment.isProjectionFn : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.EnvironmentHeader.moduleNames : (Lean.EnvironmentHeader → (Array Lean.Name)) + +lexlean_signature Lean.Expr.getAppArgs : (Lean.Expr → (Array Lean.Expr)) + +lexlean_signature Lean.Expr.getAppFn : (Lean.Expr → Lean.Expr) + +lexlean_signature Lean.Expr.getForallBody : (Lean.Expr → Lean.Expr) + +lexlean_signature Lean.Expr.getUsedConstants : (Lean.Expr → (Array Lean.Name)) + +lexlean_signature Lean.Expr.isSort : (Lean.Expr → Bool) + +lexlean_signature Lean.IR.findEnvDecl : (Lean.Environment → (Lean.Name → (Option Lean.IR.Decl))) + +lexlean_signature Lean.MessageData.compose : (Lean.MessageData → (Lean.MessageData → Lean.MessageData)) + +lexlean_signature Lean.MessageData.ofExpr : (Lean.Expr → Lean.MessageData) + +lexlean_signature Lean.MessageData.ofName : (Lean.Name → Lean.MessageData) + +lexlean_signature Lean.Meta.MetaM.run' : ({α : Type} → ((Lean.Meta.MetaM α) → ((optParam Lean.Meta.Context { }) → ((optParam Lean.Meta.State { }) → (Lean.Core.CoreM α))))) + +lexlean_signature Lean.Meta.isInstanceCore : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.Meta.isMatcherCore : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.MonadEnv.getEnv : ({m : (Type → Type)} → ([self : (Lean.MonadEnv m)] → (m Lean.Environment))) + +lexlean_signature Lean.MonadNameGenerator.setNGen : ({m : (Type → Type)} → ([self : (Lean.MonadNameGenerator m)] → (Lean.NameGenerator → (m Unit)))) + +lexlean_signature Lean.Name.components : (Lean.Name → (List Lean.Name)) + +lexlean_signature Lean.Name.eraseMacroScopes : (Lean.Name → Lean.Name) + +lexlean_signature Lean.Name.getPrefix : (Lean.Name → Lean.Name) + +lexlean_signature Lean.Name.getString! : (Lean.Name → String) + +lexlean_signature Lean.Name.isInternal : (Lean.Name → Bool) + +lexlean_signature Lean.Name.isPrefixOf : (Lean.Name → (Lean.Name → Bool)) + +lexlean_signature Lean.Name.lt : (Lean.Name → (Lean.Name → Bool)) + +lexlean_signature Lean.Name.mkSimple : (String → Lean.Name) + +lexlean_signature Lean.Name.mkStr1 : (String → Lean.Name) + +lexlean_signature Lean.Name.mkStr2 : (String → (String → Lean.Name)) + +lexlean_signature Lean.Name.toString : (Lean.Name → ((optParam Bool Bool.true) → String)) + +lexlean_signature Lean.PersistentArray.branching : USize + +lexlean_signature Lean.PersistentArray.initShift : USize + +lexlean_signature Lean.PersistentEnvExtension.toEnvExtension : ({α : Type} → ({β : Type} → ({σ : Type} → ((Lean.PersistentEnvExtension α β σ) → (Lean.EnvExtension (Lean.PersistentEnvExtensionState α σ)))))) + +lexlean_signature Lean.PersistentHashMap.mkEmptyEntriesArray : ({α : (Type u_1)} → ({β : (Type u_2)} → (Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))))) + +lexlean_signature Lean.SMap.foldStage2 : ({α : (Type u)} → ({β : (Type v)} → ([h2 : (BEq α)] → ([h3 : (Hashable α)] → ({σ : (Type w)} → ((σ → (α → (β → σ))) → (σ → ((@Lean.SMap α β h2 h3) → σ)))))))) + +lexlean_signature Lean.Syntax.getArg : (Lean.Syntax → (Nat → Lean.Syntax)) + +lexlean_signature Lean.Syntax.getId : (Lean.Syntax → Lean.Name) + +lexlean_signature Lean.annotation? : (Lean.Name → (Lean.Expr → (Option Lean.Expr))) + +lexlean_signature Lean.getConstInfo : ({m : (Type → Type)} → ([h1 : (Monad m)] → ([h2 : (Lean.MonadEnv m)] → ([h3 : (Lean.MonadError m)] → (Lean.Name → (m Lean.ConstantInfo)))))) + +lexlean_signature Lean.getOriginalConstKind? : (Lean.Environment → (Lean.Name → (Option Lean.ConstantKind))) + +lexlean_signature Lean.githash : String + +lexlean_signature Lean.instantiateMVars : ({m : (Type → Type)} → ([h1 : (Monad m)] → ([h2 : (Lean.MonadMCtx m)] → (Lean.Expr → (m Lean.Expr))))) + +lexlean_signature Lean.isAuxRecursor : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.isCasesOnRecursor : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.isNoConfusion : (Lean.Environment → (Lean.Name → Bool)) + +lexlean_signature Lean.isNoncomputable : (Lean.Environment → (Lean.Name → ((optParam Lean.EnvExtension.AsyncMode (@Lean.EnvExtension.asyncMode (Lean.PersistentEnvExtensionState Lean.Name (Prod (List Lean.Name) Lean.NameSet)) (@Lean.PersistentEnvExtension.toEnvExtension Lean.Name Lean.Name (Prod (List Lean.Name) Lean.NameSet) Lean.noncomputableExt))) → Bool))) + +lexlean_signature Lean.noncomputableExt : Lean.TagDeclarationExtension + +lexlean_signature Lean.stringToMessageData : (String → Lean.MessageData) + +lexlean_signature Lean.«throwError» : ({m : (Type → Type)} → ({α : Type} → ([h2 : (Monad m)] → ([h3 : (Lean.MonadError m)] → (Lean.MessageData → (m α)))))) + +lexlean_signature Lean.versionString : String + +lexlean_signature List.any : ({α : (Type u)} → ((List α) → ((α → Bool) → Bool))) + +lexlean_signature List.append : ({α : (Type u_1)} → ((List α) → ((List α) → (List α)))) + +lexlean_signature List.contains : ({α : (Type u)} → ([h1 : (BEq α)] → ((List α) → (α → Bool)))) + +lexlean_signature List.drop : ({α : (Type u)} → (Nat → ((List α) → (List α)))) + +lexlean_signature List.elem : ({α : (Type u)} → ([h1 : (BEq α)] → (α → ((List α) → Bool)))) + +lexlean_signature List.filter : ({α : (Type u)} → ((α → Bool) → ((List α) → (List α)))) + +lexlean_signature List.foldl : ({α : (Type u)} → ({β : (Type v)} → ((α → (β → α)) → (α → ((List β) → α))))) + +lexlean_signature List.isEmpty : ({α : (Type u)} → ((List α) → Bool)) + +lexlean_signature List.map : ({α : (Type u_1)} → ({β : (Type u_2)} → ((α → β) → ((List α) → (List β))))) + +lexlean_signature MonadLiftT.monadLift : ({m : ((Type u) → (Type v))} → ({n : ((Type u) → (Type w))} → ([self : (MonadLiftT m n)] → ({α : (Type u)} → ((m α) → (n α)))))) + +lexlean_signature Nat.add : (Nat → (Nat → Nat)) + +lexlean_signature Nat.blt : (Nat → (Nat → Bool)) + +lexlean_signature Nat.toDigits : (Nat → (Nat → (List Char))) + +lexlean_signature Option.getD : ({α : (Type u_1)} → ((Option α) → (α → α))) + +lexlean_signature Option.isSome : ({α : (Type u_1)} → ((Option α) → Bool)) + +lexlean_signature Pure.pure : ({f : ((Type u) → (Type v))} → ([self : (Pure f)] → ({α : (Type u)} → (α → (f α))))) + +lexlean_signature Std.HashMap.emptyWithCapacity : ({α : (Type u)} → ({β : (Type v)} → ([h2 : (BEq α)] → ([h3 : (Hashable α)] → ((optParam Nat 8) → (@Std.HashMap α β h2 h3)))))) + +lexlean_signature Std.HashMap.get? : ({α : (Type u)} → ({β : (Type v)} → ({h2 : (BEq α)} → ({h3 : (Hashable α)} → ((@Std.HashMap α β h2 h3) → (α → (Option β))))))) + +lexlean_signature Std.HashMap.insert : ({α : (Type u)} → ({β : (Type v)} → ({h2 : (BEq α)} → ({h3 : (Hashable α)} → ((@Std.HashMap α β h2 h3) → (α → (β → (@Std.HashMap α β h2 h3)))))))) + +lexlean_signature Std.HashSet.contains : ({α : (Type u)} → ({h1 : (BEq α)} → ({h2 : (Hashable α)} → ((@Std.HashSet α h1 h2) → (α → Bool))))) + +lexlean_signature Std.HashSet.emptyWithCapacity : ({α : (Type u)} → ([h1 : (BEq α)] → ([h2 : (Hashable α)] → ((optParam Nat 8) → (@Std.HashSet α h1 h2))))) + +lexlean_signature Std.HashSet.insert : ({α : (Type u)} → ({h1 : (BEq α)} → ({h2 : (Hashable α)} → ((@Std.HashSet α h1 h2) → (α → (@Std.HashSet α h1 h2)))))) + +lexlean_signature Std.HashSet.toList : ({α : (Type u)} → ({h1 : (BEq α)} → ({h2 : (Hashable α)} → ((@Std.HashSet α h1 h2) → (List α))))) + +lexlean_signature String.append : (String → (String → String)) + +lexlean_signature String.foldl : ({α : (Type u)} → ((α → (Char → α)) → (α → (String → α)))) + +lexlean_signature String.intercalate : (String → ((List String) → String)) + +lexlean_signature String.ofList : ((List Char) → String) + +lexlean_signature String.push : (String → (Char → String)) + +lexlean_signature String.toName : (String → Lean.Name) + +lexlean_signature ToString.toString : ({α : (Type u)} → ([self : (ToString α)] → (α → String))) + +lexlean_signature UInt16.toNat : (UInt16 → Nat) + +lexlean_signature UInt32.toNat : (UInt32 → Nat) + +lexlean_signature UInt64.toNat : (UInt64 → Nat) + +lexlean_signature UInt8.toNat : (UInt8 → Nat) + +lexlean_signature Unit.unit : Unit + +#eval LexLeanExtract.checkAuthority ((#["Array.contains", "Array.foldl", "Array.getD", "Array.isEmpty", "Array.map", "Array.size", "Array.toList", "BEq.beq", "Bind.bind", "Bool.and", "Bool.not", "Bool.or", "Char.toNat", "IO.println", "Lean.Compiler.LCNF.CompilerM.run", "Lean.Compiler.LCNF.shouldGenerateCode", "Lean.Compiler.LCNF.toDecl", "Lean.Compiler.LCNF.toLCNFType", "Lean.ConstantInfo.type", "Lean.ConstantInfo.value?", "Lean.Elab.Command.liftCoreM", "Lean.Elab.Command.liftTermElabM", "Lean.Elab.Term.elabType", "Lean.EnvExtension.asyncMode", "Lean.Environment.constants", "Lean.Environment.find?", "Lean.Environment.getModuleIdxFor?", "Lean.Environment.header", "Lean.Environment.isProjectionFn", "Lean.EnvironmentHeader.moduleNames", "Lean.Expr.getAppArgs", "Lean.Expr.getAppFn", "Lean.Expr.getForallBody", "Lean.Expr.getUsedConstants", "Lean.Expr.isSort", "Lean.IR.findEnvDecl", "Lean.MessageData.compose", "Lean.MessageData.ofExpr", "Lean.MessageData.ofName", "Lean.Meta.MetaM.run'", "Lean.Meta.isInstanceCore", "Lean.Meta.isMatcherCore", "Lean.MonadEnv.getEnv", "Lean.MonadNameGenerator.setNGen", "Lean.Name.components", "Lean.Name.eraseMacroScopes", "Lean.Name.getPrefix", "Lean.Name.getString!", "Lean.Name.isInternal", "Lean.Name.isPrefixOf", "Lean.Name.lt", "Lean.Name.mkSimple", "Lean.Name.mkStr1", "Lean.Name.mkStr2", "Lean.Name.toString", "Lean.PersistentArray.branching", "Lean.PersistentArray.initShift", "Lean.PersistentEnvExtension.toEnvExtension", "Lean.PersistentHashMap.mkEmptyEntriesArray", "Lean.SMap.foldStage2", "Lean.Syntax.getArg", "Lean.Syntax.getId", "Lean.annotation?", "Lean.getConstInfo", "Lean.getOriginalConstKind?", "Lean.githash", "Lean.instantiateMVars", "Lean.isAuxRecursor", "Lean.isCasesOnRecursor", "Lean.isNoConfusion", "Lean.isNoncomputable", "Lean.noncomputableExt", "Lean.stringToMessageData", "Lean.throwError", "Lean.versionString", "List.any", "List.append", "List.contains", "List.drop", "List.elem", "List.filter", "List.foldl", "List.isEmpty", "List.map", "MonadLiftT.monadLift", "Nat.add", "Nat.blt", "Nat.toDigits", "Option.getD", "Option.isSome", "Pure.pure", "Std.HashMap.emptyWithCapacity", "Std.HashMap.get?", "Std.HashMap.insert", "Std.HashSet.contains", "Std.HashSet.emptyWithCapacity", "Std.HashSet.insert", "Std.HashSet.toList", "String.append", "String.foldl", "String.intercalate", "String.ofList", "String.push", "String.toName", "ToString.toString", "UInt16.toNat", "UInt32.toNat", "UInt64.toNat", "UInt8.toNat", "Unit.unit"] : Array String)) ((#[(Prod.mk (α := String) (β := (Array String)) "Bool" ((#["false", "true"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Alt" ((#["alt", "ctorAlt", "default"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Arg" ((#["erased", "fvar", "type"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Cases" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Code" ((#["let", "fun", "jp", "jmp", "cases", "return", "unreach", "oset", "uset", "sset", "setTag", "inc", "dec", "del"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Decl" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.DeclValue" ((#["code", "extern"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.FunDecl" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.LetDecl" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.LetValue" ((#["lit", "erased", "proj", "const", "fvar", "ctor", "oproj", "uproj", "sproj", "fap", "pap", "reset", "reuse", "box", "unbox", "isShared"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.LitValue" ((#["nat", "str", "uint8", "uint16", "uint32", "uint64", "usize"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Param" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Phase" ((#["base", "mono", "impure"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Purity" ((#["pure", "impure"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Compiler.LCNF.Signature" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.ConstantInfo" ((#["axiomInfo", "defnInfo", "thmInfo", "opaqueInfo", "quotInfo", "inductInfo", "ctorInfo", "recInfo"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.ConstantKind" ((#["defn", "thm", "axiom", "opaque", "quot", "induct", "ctor", "recursor"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.ConstantVal" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.ConstructorVal" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.DefinitionSafety" ((#["unsafe", "safe", "partial"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.DefinitionVal" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Expr" ((#["bvar", "fvar", "mvar", "sort", "const", "app", "lam", "forallE", "letE", "lit", "mdata", "proj"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.FVarId" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.InductiveVal" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.Name" ((#["anonymous", "str", "num"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Lean.NameGenerator" ((#["mk"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "List" ((#["nil", "cons"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Option" ((#["none", "some"] : Array String))), (Prod.mk (α := String) (β := (Array String)) "Prod" ((#["mk"] : Array String)))] : Array (Prod String (Array String)))) ((#["Array", "BEq", "Bind", "Char", "Hashable", "IO", "Lean.AxiomVal", "Lean.BinderInfo", "Lean.Compiler.InlineAttributeKind", "Lean.Compiler.LCNF.CompilerM", "Lean.Compiler.LCNF.CompilerM.State", "Lean.Compiler.LCNF.CtorInfo", "Lean.ConstMap", "Lean.Core.Context", "Lean.Core.CoreM", "Lean.Core.State", "Lean.DelayedMetavarAssignment", "Lean.Elab.Command.CommandElab", "Lean.Elab.Command.CommandElabM", "Lean.Elab.Command.Context", "Lean.Elab.Command.State", "Lean.Elab.Term.Context", "Lean.Elab.Term.State", "Lean.Elab.Term.TermElabM", "Lean.EnvExtension", "Lean.EnvExtension.AsyncMode", "Lean.Environment", "Lean.EnvironmentHeader", "Lean.Exception", "Lean.ExternAttrData", "Lean.FVarIdMap", "Lean.FVarIdSet", "Lean.IR.Decl", "Lean.LMVarId", "Lean.Level", "Lean.LevelMetavarDecl", "Lean.Literal", "Lean.LocalDecl", "Lean.LocalInstance", "Lean.MData", "Lean.MVarId", "Lean.MessageData", "Lean.Meta.AbstractMVarsResult", "Lean.Meta.Config", "Lean.Meta.ConfigWithKey", "Lean.Meta.Context", "Lean.Meta.DefEqCacheKey", "Lean.Meta.DefEqContext", "Lean.Meta.ExprConfigCacheKey", "Lean.Meta.FunInfo", "Lean.Meta.InfoCacheKey", "Lean.Meta.MetaM", "Lean.Meta.PostponedEntry", "Lean.Meta.State", "Lean.Meta.SynthInstanceCacheKey", "Lean.MetavarDecl", "Lean.ModuleIdx", "Lean.MonadEnv", "Lean.MonadError", "Lean.MonadMCtx", "Lean.MonadNameGenerator", "Lean.NameSet", "Lean.OpaqueVal", "Lean.ParserDescr", "Lean.PersistentArrayNode", "Lean.PersistentEnvExtension", "Lean.PersistentEnvExtensionState", "Lean.PersistentHashMap.Entry", "Lean.PersistentHashMap.Node", "Lean.QuotVal", "Lean.RecursorVal", "Lean.ReducibilityHints", "Lean.SMap", "Lean.Syntax", "Lean.TagDeclarationExtension", "Lean.TheoremVal", "Monad", "MonadLiftT", "Nat", "Pure", "Std.HashMap", "Std.HashSet", "String", "ToString", "UInt16", "UInt32", "UInt64", "UInt8", "USize", "Unit"] : Array String)) ((#["Applicative.toPure", "Array.casesOn", "Array.mkEmpty", "Bool.casesOn", "Char.ofNat", "EIO", "EmptyCollection.emptyCollection", "Eq", "Eq.casesOn", "Eq.ndrec", "Eq.refl", "Eq.symm", "False", "False.elim", "HEq", "HEq.refl", "IO.RealWorld", "Inhabited", "Inhabited.default", "Inhabited.mk", "Lean.Compiler.LCNF.Alt.casesOn", "Lean.Compiler.LCNF.Arg.casesOn", "Lean.Compiler.LCNF.Cases.casesOn", "Lean.Compiler.LCNF.Code.casesOn", "Lean.Compiler.LCNF.CompilerM.State.mk", "Lean.Compiler.LCNF.CtorInfo.casesOn", "Lean.Compiler.LCNF.Decl.toSignature", "Lean.Compiler.LCNF.Decl.value", "Lean.Compiler.LCNF.DeclValue.casesOn", "Lean.Compiler.LCNF.FunDecl.casesOn", "Lean.Compiler.LCNF.LCtx.mk", "Lean.Compiler.LCNF.LetDecl.fvarId", "Lean.Compiler.LCNF.LetDecl.type", "Lean.Compiler.LCNF.LetDecl.value", "Lean.Compiler.LCNF.LetValue.casesOn", "Lean.Compiler.LCNF.LitValue.casesOn", "Lean.Compiler.LCNF.Param.borrow", "Lean.Compiler.LCNF.Param.fvarId", "Lean.Compiler.LCNF.Param.type", "Lean.Compiler.LCNF.Purity.ctorIdx", "Lean.Compiler.LCNF.Signature.levelParams", "Lean.Compiler.LCNF.Signature.name", "Lean.Compiler.LCNF.Signature.params", "Lean.Compiler.LCNF.Signature.safe", "Lean.Compiler.LCNF.Signature.type", "Lean.ConstantInfo.casesOn", "Lean.ConstantInfo.ctorIdx", "Lean.ConstantInfo.rec", "Lean.ConstantKind.casesOn", "Lean.ConstantVal.type", "Lean.ConstructorVal.induct", "Lean.ConstructorVal.numFields", "Lean.ConstructorVal.numParams", "Lean.ConstructorVal.toConstantVal", "Lean.Core.instAddMessageContextCoreM", "Lean.Core.instInhabitedCoreM", "Lean.Core.instMonadCoreM", "Lean.Core.instMonadEnvCoreM", "Lean.Core.instMonadLiftIOCoreM", "Lean.Core.instMonadNameGeneratorCoreM", "Lean.Core.instMonadRefCoreM", "Lean.DefinitionSafety.casesOn", "Lean.DefinitionVal.safety", "Lean.Elab.Command.instAddErrorMessageContextCommandElabM", "Lean.Elab.Command.instInhabitedCommandElabM", "Lean.Elab.Command.instMonadCommandElabM", "Lean.Elab.Command.instMonadEnvCommandElabM", "Lean.Elab.Command.instMonadExceptOfExceptionCommandElabM", "Lean.Elab.Command.instMonadLiftTIOCommandElabM", "Lean.Elab.Command.instMonadRefCommandElabM", "Lean.Elab.MonadMacroAdapter.toMonadQuotation", "Lean.Elab.Term.instAddErrorMessageContextTermElabM", "Lean.Elab.Term.instMonadMacroAdapterTermElabM", "Lean.Elab.Term.instMonadTermElabM", "Lean.Expr.casesOn", "Lean.Expr.ctorIdx", "Lean.Expr.instBEq", "Lean.Expr.instHashable", "Lean.Expr.rec", "Lean.FVarId.casesOn", "Lean.FVarId.name", "Lean.InductiveVal.ctors", "Lean.InductiveVal.isRec", "Lean.InductiveVal.numIndices", "Lean.InductiveVal.numParams", "Lean.Level.instBEq", "Lean.Level.instToString", "Lean.LocalContext.mk", "Lean.Meta.Cache.mk", "Lean.Meta.Context.mk", "Lean.Meta.Diagnostics.mk", "Lean.Meta.State.mk", "Lean.Meta.instBEqDefEqCacheKey", "Lean.Meta.instBEqExprConfigCacheKey", "Lean.Meta.instBEqInfoCacheKey", "Lean.Meta.instBEqSynthInstanceCacheKey", "Lean.Meta.instHashableDefEqCacheKey", "Lean.Meta.instHashableExprConfigCacheKey", "Lean.Meta.instHashableInfoCacheKey", "Lean.Meta.instHashableSynthInstanceCacheKey", "Lean.Meta.instInhabitedConfigWithKey", "Lean.Meta.instMonadEnvMetaM", "Lean.Meta.instMonadMCtxMetaM", "Lean.Meta.instMonadMetaM", "Lean.MetavarContext.mk", "Lean.MonadError.mk", "Lean.MonadQuotation.toMonadRef", "Lean.Name.instBEq", "Lean.ParserDescr.binary", "Lean.ParserDescr.cat", "Lean.ParserDescr.const", "Lean.ParserDescr.node", "Lean.ParserDescr.symbol", "Lean.PersistentArray.mk", "Lean.PersistentArrayNode.node", "Lean.PersistentHashMap.Node.entries", "Lean.PersistentHashMap.mk", "Lean.instAddErrorMessageContextOfAddMessageContextOfMonad", "Lean.instBEqBinderInfo", "Lean.instBEqFVarId", "Lean.instBEqLevelMVarId", "Lean.instBEqLiteral", "Lean.instBEqMVarId", "Lean.instEmptyCollectionFVarIdMap", "Lean.instEmptyCollectionFVarIdSet", "Lean.instHashableFVarId", "Lean.instHashableLevelMVarId", "Lean.instHashableMVarId", "Lean.instHashableName", "Lean.instMonadEnvOfMonadLift", "Lean.instMonadExceptOfExceptionCoreM", "Lean.instMonadMCtxOfMonadLift", "List.casesOn", "List.instBEq", "List.toArray", "Monad.toBind", "Nat.hasNotBit", "Nat.land", "Nat.ne_of_beq_eq_false", "Nat.shiftRight", "OfNat.ofNat", "Option.casesOn", "Prod.fst", "Prod.snd", "ReaderT.instApplicativeOfMonad", "ReaderT.instMonadExceptOf", "ReaderT.instMonadLift", "StateRefT'", "StateRefT'.instMonad", "StateRefT'.instMonadExceptOf", "StateRefT'.instMonadLift", "Std.HashMap.instEmptyCollection", "String.instInhabited", "USize.toNat", "eq_of_heq", "instBEqOfDecidableEq", "instDecidableEqBool", "instDecidableEqChar", "instDecidableEqNat", "instDecidableEqString", "instInhabitedBool", "instInhabitedList", "instInhabitedProd", "instMonadEIO", "instMonadLiftT", "instMonadLiftTOfMonadLift", "instOfNatNat", "instToStringList", "instToStringNat", "instToStringString", "ite", "noConfusion_of_Nat"] : Array String)) + +#eval LexLeanExtract.main ((#["LexLeanStd.Text.startsWith", "LexLeanStd.Text.endsWith", "LexLeanStd.Text.trim", "LexLeanStd.Text.splitOn", "LexLeanStd.Text.lines", "LexLeanStd.Text.joinWith", "LexLeanStd.Text.find"] : Array String)) ((#["LexLeanRuntime.Portable", "LexLeanRuntime.Collections", "LexLeanStd.Text"] : Array String)) diff --git a/stdlib/expected/verify/extract/process.json b/stdlib/expected/verify/extract/process.json new file mode 100644 index 0000000000..a449286595 --- /dev/null +++ b/stdlib/expected/verify/extract/process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/extract/LexLeanExtract.Xb4a41a9b6af3776bed9cd860f1a4f2d9.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanExtract.Xb4a41a9b6af3776bed9cd860f1a4f2d9","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/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0.lean new file mode 100644 index 0000000000..45a48d5576 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0.lean @@ -0,0 +1,33 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«match» .bool (.prim .slice [(.var 0), (.value .nat (.nat 0)), (.prim .length [(.var 1)])]) [(.arm .some [2] (.prim .equal [(.var 2), (.var 1)])), (.arm .none [] (.build .false .bool []))]) }] } + +def __fits_0 (subject : ByteArray) («prefix» : ByteArray) : Bool := + (((Bool.true && (Bool.true && (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length («prefix») : Nat) 18446744073709551616)) && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) ((0 : Nat)) ((_root_.LexLeanRuntime.length («prefix») : Nat)) : (Option ByteArray)) with | Option.some head => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) + +theorem __rel_0 (subject : ByteArray) («prefix» : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some head => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bool (match __a with | Option.some head => (_root_.LexLeanRuntime.equal (head) («prefix») : Bool) | Option.none => Bool.false)) (_root_.LexLeanRuntime.slice (subject) ((0 : Nat)) ((_root_.LexLeanRuntime.length («prefix») : Nat)) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes «prefix»)) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.prim_slice_bytes subject (0 : Nat) (_root_.LexLeanRuntime.length («prefix») : Nat))) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some head => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_bytes head «prefix»))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false))))) + +def denote (subject : ByteArray) («prefix» : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject «prefix») (_root_.LexLeanPreservation.Obs.value ((_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.startsWith subject «prefix»)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..79b5e2652f --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/Compose/RustStd.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.root : @916 := @917 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.flags +@3 := ByteArray +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (b : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@66 := Prod.{0, 0} @63 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.false +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.__fits_0 +@327 := @325 @4 @15 +@330 := LexLeanStd.Text.startsWith @4 @15 +@332 := LexLeanTarget.TargetSyntax.Value.bool @330 +@335 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.root @4 @15 +@336 := Bool +@337 := Ne.{1} +@338 := LexLeanPreservation.Obs +@339 := @337 @338 +@340 := LexLeanPreservation.Rel +@343 := @339 (@340 @15 @17) +@344 := LexLeanPreservation.Obs.stuck +@347 := (f : @336) -> (v : @54) -> @343 @344 +@349 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@356 := (v : @54) -> @339 (@340 (@325 @12 @4) @17) @344 +@357 := @349 @332 +@361 := @339 (@340 @327 @332) @344 +@362 := @136 @66 +@363 := LexLeanPreservation.Rust.FunSem +@364 := #9 +@370 := (n : @63) -> @363 @364 @153 @147 @17 @139 +@371 := Eq.{1} +@372 := Option.{0} +@373 := @372 @83 +@374 := @371 @373 +@381 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@385 := @374 (@381 (@84 @364) @139) +@386 := Option.some.{0} +@387 := @386 @83 +@388 := @387 @141 +@389 := @385 @388 +@390 := #10 +@394 := @108 @390 @364 @153 @141 +@395 := LexLeanTarget.TargetSyntax.Function.types +@396 := @395 @139 +@397 := @394 @396 +@398 := @372 @362 +@399 := @371 @398 +@400 := LexLeanTarget.TargetSemantics.bindAll +@401 := LexLeanTarget.TargetSyntax.Function.parameters +@406 := @399 (@400 (@401 @147) @139 @76) +@407 := @386 @362 +@408 := @407 @141 +@409 := @406 @408 +@410 := @372 @336 +@411 := @371 @410 +@412 := LexLeanPreservation.Rust.fnFallible +@413 := #11 +@416 := @411 (@412 @413 @364) +@417 := @386 @336 +@418 := @417 @141 +@419 := @416 @418 +@420 := LexLeanPreservation.RunConv +@421 := #13 +@425 := @420 @421 @390 @153 @141 +@427 := @339 @139 @344 +@428 := Exists.{1} +@429 := LexLeanPreservation.Rust.ROut +@430 := @428 @429 +@431 := And +@432 := LexLeanPreservation.Rust.RealizesFn +@436 := @431 (@432 @364 @153 @17) +@437 := LexLeanPreservation.Rust.RCI +@439 := @437 #15 +@440 := LexLeanPreservation.Rust.fnIdent +@441 := @440 @421 +@448 := (hne : @427) -> @430 (fun (ro : @429) => @436 (@439 @441 @413 @17)) +@463 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @370) -> + (hfn : @389) -> (hwt : @397) -> (hbind : @409) -> (hF : @419) -> (hA : @425) -> @448 +@465 := LexLeanPreservation.Rust.compose @0 +@466 := @363 @0 +@471 := (n : @63) -> @466 @153 @147 @17 @139 +@472 := @381 @85 +@475 := @374 (@472 @139) @388 +@479 := @119 @364 @153 @141 @396 +@480 := @420 @0 +@483 := @480 @390 @153 @141 +@497 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @471) -> + (hfn : @475) -> (hwt : @479) -> (hbind : @409) -> (hF : @419) -> (hA : @483) -> @448 +@498 := @465 @1 +@499 := @466 @1 +@503 := (n : @63) -> @499 @147 @17 @139 +@506 := @127 @153 @141 @396 +@507 := @412 @1 +@510 := @411 (@507 @364) @418 +@511 := @437 @1 +@521 := (hbind : @409) -> + (hF : @510) -> (hA : @483) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@511 @441 @413 @17)) +@531 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> {F : @336} -> {o : @338} -> (hB : @503) -> (hfn : @475) -> (hwt : @506) -> @521 +@532 := @498 @2 +@534 := @499 @2 @17 +@536 := (n : @63) -> @534 @139 +@537 := @133 @141 +@538 := @537 @396 +@547 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> {F : @336} -> {o : @338} -> (hB : @536) -> (hfn : @475) -> (hwt : @538) -> @521 +@548 := @532 @73 +@550 := (n : @63) -> @534 @73 +@551 := @472 @73 +@552 := @374 @551 +@553 := @552 @388 +@554 := @507 @73 +@555 := @411 @554 +@556 := @555 @418 +@557 := @480 @73 +@559 := @557 @153 @141 +@561 := @511 (@440 @73) +@569 := (hF : @556) -> (hA : @559) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 @413 @17)) +@578 := {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> {o : @338} -> (hB : @550) -> (hfn : @553) -> (hwt : @538) -> (hbind : @409) -> @569 +@579 := @548 @103 +@581 := @552 (@387 @103) +@582 := @395 @103 +@583 := @537 @582 +@585 := @400 (@401 @103) +@597 := {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @550) -> (hfn : @581) -> (hwt : @583) -> (hbind : @399 (@585 @139 @76) @408) -> @569 +@598 := @579 @62 +@600 := @283 (@230 @57) +@602 := @133 @600 @582 +@604 := @58 (@5 @153) +@606 := @604 (@283 @57) +@610 := @399 (@585 @606 @76) @408 +@612 := @58 (@5 @390) +@614 := @58 (@5 @364) +@616 := @612 (@614 @57) +@618 := @557 @616 @141 +@620 := @58 (@5 @421) +@623 := @58 (@5 #12) +@640 := {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @602) -> + (hbind : @610) -> + (hF : @556) -> + (hA : @618) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 (@620 (@623 @57)) @17)) +@641 := @598 @81 +@643 := @230 (@244 @57) +@645 := @133 @643 @582 +@656 := @399 (@585 @600 @76) (@407 (@77 (@71 @229) (@77 (@74 @282) @76))) +@658 := @614 (@604 @57) +@660 := @557 @658 @141 +@662 := @58 (@5 @413) +@678 := {F : @336} -> + {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @645) -> + (hbind : @656) -> + (hF : @556) -> + (hA : @660) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 (@623 (@662 @57)) @17)) +@679 := @641 @82 +@680 := @302 @582 +@691 := @399 (@585 @643 @76) (@407 (@77 (@71 @243) (@77 (@74 @229) @76))) +@693 := @555 (@417 @82) +@695 := @557 @606 @141 +@696 := @432 @82 +@714 := {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @680) -> + (hbind : @691) -> + (hF : @693) -> + (hA : @695) -> + (hne : @427) -> @430 (fun (ro : @429) => @431 (@696 @153 @17) (@561 (@662 (@612 @57)) @17)) +@715 := @679 @324 +@716 := @309 @582 +@727 := @399 (@585 @301 @76) (@407 (@77 (@71 @226) (@77 (@74 @243) @76))) +@728 := @557 @600 +@730 := @322 @147 @139 +@731 := @728 @730 +@733 := @322 @153 @147 +@752 := (hB : @550) -> + (hfn : @581) -> + (hwt : @716) -> + (hbind : @727) -> + (hF : @693) -> + (hA : @731) -> + (hne : @339 @733 @344) -> + @430 (fun (ro : @429) => @431 (@696 (@322 @390 @364) @17) (@561 @616 @17)) +@753 := @715 @107 +@754 := @316 @582 +@765 := @399 (@585 @308 @76) (@407 (@77 (@71 @240) (@77 (@74 @226) @76))) +@766 := @557 @643 +@768 := @322 @139 @141 +@787 := (hfn : @581) -> + (hwt : @754) -> + (hbind : @765) -> + (hF : @693) -> + (hA : @766 @768) -> + (hne : @339 @730 @344) -> + @430 (fun (ro : @429) => @431 (@696 (@322 @364 @153) @17) (@561 @658 @17)) +@788 := Eq.refl.{1} +@791 := @753 (@788 @373 @551) +@792 := @320 @582 +@803 := @399 (@585 @315 @76) (@407 (@77 (@71 @6) (@77 (@74 @240) @76))) +@804 := @557 @301 +@806 := @322 @141 @143 +@822 := (hwt : @792) -> + (hbind : @803) -> + (hF : @693) -> + (hA : @804 @806) -> + (hne : @339 @768 @344) -> @430 (fun (ro : @429) => @431 (@696 @733 @17) (@561 @606 @17)) +@823 := @791 @319 +@825 := @585 @62 @76 +@828 := @399 @825 (@407 @81) +@829 := @557 @308 +@831 := @322 @143 @12 +@846 := (hbind : @828) -> + (hF : @693) -> + (hA : @829 @831) -> + (hne : @339 @806 @344) -> @430 (fun (ro : @429) => @431 (@696 @730 @17) (@561 @600 @17)) +@849 := @823 (@788 @398 @825) +@850 := @557 @315 +@852 := @322 @12 @4 +@866 := (hF : @693) -> + (hA : @850 @852) -> + (hne : @339 @831 @344) -> @430 (fun (ro : @429) => @431 (@696 @768 @17) (@561 @643 @17)) +@869 := @849 (@788 @410 @554) +@883 := (hA : @557 @62 @324) -> + (hne : @339 @852 @344) -> @430 (fun (ro : @429) => @431 (@696 @806 @17) (@561 @301 @17)) +@884 := @869 @335 +@895 := (hne : @339 @324 @344) -> @430 (fun (ro : @429) => @431 (@696 @831 @17) (@561 @308 @17)) +@896 := @884 @357 +@902 := @431 (@696 @852 @17) (@561 @315 @17) +@904 := @430 (fun (ro : @429) => @902) +@906 := @430 (fun (__e_ro : @429) => @902) +@911 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@912 := (__e_hrep : @911) -> @906 +@913 := fun (__e_hrep : @911) => @896 +@914 := (prefix : @3) -> @912 +@915 := fun (prefix : @3) => @913 +@916 := (subject : @3) -> @914 +@917 := fun (subject : @3) => @915 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/RustStd.lean new file mode 100644 index 0000000000..3d940bf489 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/RustStd.lean @@ -0,0 +1,33 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«match» .bool (.prim .slice [(.var 0), (.value .nat (.nat 0)), (.prim .length [(.var 1)])]) [(.arm .some [2] (.prim .equal [(.var 2), (.var 1)])), (.arm .none [] (.build .false .bool []))]) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] .bool (.mk [(.mk (.bind (.generated .holder 5)) none (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 3)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 4)) none (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false))))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 2)), (.move (.generated .operand 3)), (.move (.generated .operand 4))] false))))] (.matchOn (.move (.generated .holder 5)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 2))) (.mk [(.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 2))), (.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 6)), (.move (.generated .operand 7))] false)))])))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 5)) none (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 3)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 4)) none (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false))))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 2)), (.move (.generated .operand 3)), (.move (.generated .operand 4))] false))))], (.matchOn (.move (.generated .holder 5)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 2))) (.mk [(.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 2))), (.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 6)), (.move (.generated .operand 7))] false)))]), [(1, .bytes, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 2)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 3)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 4)) none (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false))))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 2)), (.move (.generated .operand 3)), (.move (.generated .operand 4))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 1)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bool false))) (Corr.mCons (Γ' := [(2, .bytes, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 2))), (.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 1)))]) (tail := (.call (.runtime .equal) [(.move (.generated .operand 6)), (.move (.generated .operand 7))] false)) (Corr.mNil) rfl rfl rfl (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.buildConst rfl))) rfl rfl rfl)⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | _ + 1 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1.lean new file mode 100644 index 0000000000..0d5826b28e --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1.lean @@ -0,0 +1,33 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.cond (.prim .natLe [(.var 3), (.var 2)]) (.«match» .bool (.prim .slice [(.var 0), (.prim .natSub [(.var 2), (.var 3)]), (.var 3)]) [(.arm .some [4] (.prim .equal [(.var 4), (.var 1)])), (.arm .none [] (.build .false .bool []))]) (.build .false .bool [])))) }] } + +def __fits_0 (subject : ByteArray) (suffix : ByteArray) : Bool := + (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (suffix) : Nat) 18446744073709551616)) && (let size : Nat := (_root_.LexLeanRuntime.length (suffix) : Nat); (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.ble size total) then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) else (Bool.true && Bool.true))))))) + +theorem __rel_0 (subject : ByteArray) (suffix : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (let size : Nat := (_root_.LexLeanRuntime.length (suffix) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes suffix)) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) else (Bool.true && Bool.true))) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (if __b then (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => (_root_.LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => Bool.false) else Bool.false)) (Nat.ble size total) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLe size total)) (fun _ => (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bool (match __a with | Option.some tail => (_root_.LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => Bool.false)) (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub total size)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.prim_slice_bytes subject (_root_.LexLeanRuntime.subtract (total) (size) : Nat) size)) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some tail => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_bytes tail suffix))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false)))))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false))))) + +def denote (subject : ByteArray) (suffix : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject suffix) (_root_.LexLeanPreservation.Obs.value ((_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.endsWith subject suffix)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..210a3362b2 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/Compose/RustStd.lex.tex @@ -0,0 +1,464 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.root : @916 := @917 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.flags +@3 := ByteArray +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (b : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@66 := Prod.{0, 0} @63 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.false +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.__fits_0 +@327 := @325 @4 @15 +@330 := LexLeanStd.Text.endsWith @4 @15 +@332 := LexLeanTarget.TargetSyntax.Value.bool @330 +@335 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.root @4 @15 +@336 := Bool +@337 := Ne.{1} +@338 := LexLeanPreservation.Obs +@339 := @337 @338 +@340 := LexLeanPreservation.Rel +@343 := @339 (@340 @15 @17) +@344 := LexLeanPreservation.Obs.stuck +@347 := (f : @336) -> (v : @54) -> @343 @344 +@349 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@356 := (v : @54) -> @339 (@340 (@325 @12 @4) @17) @344 +@357 := @349 @332 +@361 := @339 (@340 @327 @332) @344 +@362 := @136 @66 +@363 := LexLeanPreservation.Rust.FunSem +@364 := #9 +@370 := (n : @63) -> @363 @364 @153 @147 @17 @139 +@371 := Eq.{1} +@372 := Option.{0} +@373 := @372 @83 +@374 := @371 @373 +@381 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@385 := @374 (@381 (@84 @364) @139) +@386 := Option.some.{0} +@387 := @386 @83 +@388 := @387 @141 +@389 := @385 @388 +@390 := #10 +@394 := @108 @390 @364 @153 @141 +@395 := LexLeanTarget.TargetSyntax.Function.types +@396 := @395 @139 +@397 := @394 @396 +@398 := @372 @362 +@399 := @371 @398 +@400 := LexLeanTarget.TargetSemantics.bindAll +@401 := LexLeanTarget.TargetSyntax.Function.parameters +@406 := @399 (@400 (@401 @147) @139 @76) +@407 := @386 @362 +@408 := @407 @141 +@409 := @406 @408 +@410 := @372 @336 +@411 := @371 @410 +@412 := LexLeanPreservation.Rust.fnFallible +@413 := #11 +@416 := @411 (@412 @413 @364) +@417 := @386 @336 +@418 := @417 @141 +@419 := @416 @418 +@420 := LexLeanPreservation.RunConv +@421 := #13 +@425 := @420 @421 @390 @153 @141 +@427 := @339 @139 @344 +@428 := Exists.{1} +@429 := LexLeanPreservation.Rust.ROut +@430 := @428 @429 +@431 := And +@432 := LexLeanPreservation.Rust.RealizesFn +@436 := @431 (@432 @364 @153 @17) +@437 := LexLeanPreservation.Rust.RCI +@439 := @437 #15 +@440 := LexLeanPreservation.Rust.fnIdent +@441 := @440 @421 +@448 := (hne : @427) -> @430 (fun (ro : @429) => @436 (@439 @441 @413 @17)) +@463 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @370) -> + (hfn : @389) -> (hwt : @397) -> (hbind : @409) -> (hF : @419) -> (hA : @425) -> @448 +@465 := LexLeanPreservation.Rust.compose @0 +@466 := @363 @0 +@471 := (n : @63) -> @466 @153 @147 @17 @139 +@472 := @381 @85 +@475 := @374 (@472 @139) @388 +@479 := @119 @364 @153 @141 @396 +@480 := @420 @0 +@483 := @480 @390 @153 @141 +@497 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @471) -> + (hfn : @475) -> (hwt : @479) -> (hbind : @409) -> (hF : @419) -> (hA : @483) -> @448 +@498 := @465 @1 +@499 := @466 @1 +@503 := (n : @63) -> @499 @147 @17 @139 +@506 := @127 @153 @141 @396 +@507 := @412 @1 +@510 := @411 (@507 @364) @418 +@511 := @437 @1 +@521 := (hbind : @409) -> + (hF : @510) -> (hA : @483) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@511 @441 @413 @17)) +@531 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> {F : @336} -> {o : @338} -> (hB : @503) -> (hfn : @475) -> (hwt : @506) -> @521 +@532 := @498 @2 +@534 := @499 @2 @17 +@536 := (n : @63) -> @534 @139 +@537 := @133 @141 +@538 := @537 @396 +@547 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @362} -> {F : @336} -> {o : @338} -> (hB : @536) -> (hfn : @475) -> (hwt : @538) -> @521 +@548 := @532 @73 +@550 := (n : @63) -> @534 @73 +@551 := @472 @73 +@552 := @374 @551 +@553 := @552 @388 +@554 := @507 @73 +@555 := @411 @554 +@556 := @555 @418 +@557 := @480 @73 +@559 := @557 @153 @141 +@561 := @511 (@440 @73) +@569 := (hF : @556) -> (hA : @559) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 @413 @17)) +@578 := {fn : @83} -> + {args : @137} -> + {env : @362} -> + {F : @336} -> {o : @338} -> (hB : @550) -> (hfn : @553) -> (hwt : @538) -> (hbind : @409) -> @569 +@579 := @548 @103 +@581 := @552 (@387 @103) +@582 := @395 @103 +@583 := @537 @582 +@585 := @400 (@401 @103) +@597 := {args : @137} -> + {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @550) -> (hfn : @581) -> (hwt : @583) -> (hbind : @399 (@585 @139 @76) @408) -> @569 +@598 := @579 @62 +@600 := @283 (@230 @57) +@602 := @133 @600 @582 +@604 := @58 (@5 @153) +@606 := @604 (@283 @57) +@610 := @399 (@585 @606 @76) @408 +@612 := @58 (@5 @390) +@614 := @58 (@5 @364) +@616 := @612 (@614 @57) +@618 := @557 @616 @141 +@620 := @58 (@5 @421) +@623 := @58 (@5 #12) +@640 := {env : @362} -> + {F : @336} -> + {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @602) -> + (hbind : @610) -> + (hF : @556) -> + (hA : @618) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 (@620 (@623 @57)) @17)) +@641 := @598 @81 +@643 := @230 (@244 @57) +@645 := @133 @643 @582 +@656 := @399 (@585 @600 @76) (@407 (@77 (@71 @229) (@77 (@74 @282) @76))) +@658 := @614 (@604 @57) +@660 := @557 @658 @141 +@662 := @58 (@5 @413) +@678 := {F : @336} -> + {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @645) -> + (hbind : @656) -> + (hF : @556) -> + (hA : @660) -> (hne : @427) -> @430 (fun (ro : @429) => @436 (@561 (@623 (@662 @57)) @17)) +@679 := @641 @82 +@680 := @302 @582 +@691 := @399 (@585 @643 @76) (@407 (@77 (@71 @243) (@77 (@74 @229) @76))) +@693 := @555 (@417 @82) +@695 := @557 @606 @141 +@696 := @432 @82 +@714 := {o : @338} -> + (hB : @550) -> + (hfn : @581) -> + (hwt : @680) -> + (hbind : @691) -> + (hF : @693) -> + (hA : @695) -> + (hne : @427) -> @430 (fun (ro : @429) => @431 (@696 @153 @17) (@561 (@662 (@612 @57)) @17)) +@715 := @679 @324 +@716 := @309 @582 +@727 := @399 (@585 @301 @76) (@407 (@77 (@71 @226) (@77 (@74 @243) @76))) +@728 := @557 @600 +@730 := @322 @147 @139 +@731 := @728 @730 +@733 := @322 @153 @147 +@752 := (hB : @550) -> + (hfn : @581) -> + (hwt : @716) -> + (hbind : @727) -> + (hF : @693) -> + (hA : @731) -> + (hne : @339 @733 @344) -> + @430 (fun (ro : @429) => @431 (@696 (@322 @390 @364) @17) (@561 @616 @17)) +@753 := @715 @107 +@754 := @316 @582 +@765 := @399 (@585 @308 @76) (@407 (@77 (@71 @240) (@77 (@74 @226) @76))) +@766 := @557 @643 +@768 := @322 @139 @141 +@787 := (hfn : @581) -> + (hwt : @754) -> + (hbind : @765) -> + (hF : @693) -> + (hA : @766 @768) -> + (hne : @339 @730 @344) -> + @430 (fun (ro : @429) => @431 (@696 (@322 @364 @153) @17) (@561 @658 @17)) +@788 := Eq.refl.{1} +@791 := @753 (@788 @373 @551) +@792 := @320 @582 +@803 := @399 (@585 @315 @76) (@407 (@77 (@71 @6) (@77 (@74 @240) @76))) +@804 := @557 @301 +@806 := @322 @141 @143 +@822 := (hwt : @792) -> + (hbind : @803) -> + (hF : @693) -> + (hA : @804 @806) -> + (hne : @339 @768 @344) -> @430 (fun (ro : @429) => @431 (@696 @733 @17) (@561 @606 @17)) +@823 := @791 @319 +@825 := @585 @62 @76 +@828 := @399 @825 (@407 @81) +@829 := @557 @308 +@831 := @322 @143 @12 +@846 := (hbind : @828) -> + (hF : @693) -> + (hA : @829 @831) -> + (hne : @339 @806 @344) -> @430 (fun (ro : @429) => @431 (@696 @730 @17) (@561 @600 @17)) +@849 := @823 (@788 @398 @825) +@850 := @557 @315 +@852 := @322 @12 @4 +@866 := (hF : @693) -> + (hA : @850 @852) -> + (hne : @339 @831 @344) -> @430 (fun (ro : @429) => @431 (@696 @768 @17) (@561 @643 @17)) +@869 := @849 (@788 @410 @554) +@883 := (hA : @557 @62 @324) -> + (hne : @339 @852 @344) -> @430 (fun (ro : @429) => @431 (@696 @806 @17) (@561 @301 @17)) +@884 := @869 @335 +@895 := (hne : @339 @324 @344) -> @430 (fun (ro : @429) => @431 (@696 @831 @17) (@561 @308 @17)) +@896 := @884 @357 +@902 := @431 (@696 @852 @17) (@561 @315 @17) +@904 := @430 (fun (ro : @429) => @902) +@906 := @430 (fun (__e_ro : @429) => @902) +@911 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@912 := (__e_hrep : @911) -> @906 +@913 := fun (__e_hrep : @911) => @896 +@914 := (suffix : @3) -> @912 +@915 := fun (suffix : @3) => @913 +@916 := (subject : @3) -> @914 +@917 := fun (subject : @3) => @915 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/RustStd.lean new file mode 100644 index 0000000000..ebd35726bc --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/RustStd.lean @@ -0,0 +1,33 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.cond (.prim .natLe [(.var 3), (.var 2)]) (.«match» .bool (.prim .slice [(.var 0), (.prim .natSub [(.var 2), (.var 3)]), (.var 3)]) [(.arm .some [4] (.prim .equal [(.var 4), (.var 1)])), (.arm .none [] (.build .false .bool []))]) (.build .false .bool [])))) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] .bool (.mk [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)))), (.mk (.bind (.generated .operand 3)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2)))] (.cond (.call (.runtime .natLe) [(.move (.generated .operand 3)), (.move (.generated .operand 4))] false) (.mk [(.mk (.bind (.generated .holder 10)) none (.block (.mk [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false))))] (.matchOn (.move (.generated .holder 10)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 11)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false)))])) (.mk [] (.lit (.bool false))))))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)))), (.mk (.bind (.generated .operand 3)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2)))], (.cond (.call (.runtime .natLe) [(.move (.generated .operand 3)), (.move (.generated .operand 4))] false) (.mk [(.mk (.bind (.generated .holder 10)) none (.block (.mk [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false))))] (.matchOn (.move (.generated .holder 10)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 11)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false)))])) (.mk [] (.lit (.bool false)))), [(1, .bytes, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.cond (lc := [(.mk (.bind (.generated .operand 3)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2)))]) (ce := (.call (.runtime .natLe) [(.move (.generated .operand 3)), (.move (.generated .operand 4))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := [(.mk (.bind (.generated .holder 10)) none (.block (.mk [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false))))]) (ta := (.matchOn (.move (.generated .holder 10)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 11)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false)))])) (lb := []) (tb := (.lit (.bool false))) (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bool false))) (Corr.mCons (Γ' := [(4, .bytes, (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 11)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 1)))]) (tail := (.call (.runtime .equal) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false)) (Corr.mNil) rfl rfl rfl (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.buildConst rfl))) rfl rfl rfl) (Corr.bOfE (Corr.buildConst rfl))))))⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | _ + 1 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2.lean new file mode 100644 index 0000000000..b749d46057 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2.lean @@ -0,0 +1,105 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0], types := [.bytes], result := .bytes, + body := (.«let» 1 .nat (.call 1 [(.var 0)]) (.«let» 2 .nat (.call 2 [(.var 0), (.var 1)]) (.call 3 [(.var 0), (.var 2), (.prim .natSub [(.var 1), (.var 2)])]))) }, + { parameters := [0], types := [.bytes], result := .nat, + body := (.first (.call 4 [(.closure 5 [(.var 0)]), (.prim .length [(.var 0)]), (.prim .length [(.var 0)])])) }, + { parameters := [0, 1], types := [.bytes, .nat], result := .nat, + body := (.first (.call 4 [(.closure 6 [(.var 1), (.var 0)]), (.var 1), (.value .nat (.nat 0))])) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [(.fn [.nat] (.option .nat)), .nat, .nat], result := (.pair .nat .bool), + body := (.«match» (.pair .nat .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair .nat .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 4 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option .nat), + body := (.cond (.prim .natLt [(.value .nat (.nat 0)), (.var 1)]) (.cond (.call 7 [(.var 0), (.prim .natSub [(.var 1), (.value .nat (.nat 1))])]) (.build .some (.option .nat) [(.prim .natSub [(.var 1), (.value .nat (.nat 1))])]) (.build .none (.option .nat) [])) (.build .none (.option .nat) [])) }, + { parameters := [0, 1, 2], types := [.nat, .bytes, .nat], result := (.option .nat), + body := (.cond (.prim .natLt [(.var 2), (.var 0)]) (.cond (.call 7 [(.var 1), (.var 2)]) (.build .some (.option .nat) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))])]) (.build .none (.option .nat) [])) (.build .none (.option .nat) [])) }, + { parameters := [0, 1], types := [.bytes, .nat], result := .bool, + body := (.«match» .bool (.call 8 [(.var 0), (.var 1)]) [(.arm .some [2] (.call 9 [(.var 2)])), (.arm .none [] (.build .false .bool []))]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }, + { parameters := [0], types := [(.fixed .u8)], result := .bool, + body := (.cond (.cond (.cond (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 32))]) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 9))])) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 10))])) (.build .true .bool []) (.cond (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 12))]) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 13))]))) }] } + +def __fits_8 (subject : ByteArray) (position : Nat) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && Bool.true) + +theorem __rel_8 (subject : ByteArray) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 8 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_8 subject position) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (LexLeanStd.Text.byteAt subject position))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_index_bytes subject position)) + +def __fits_9 (byte : UInt8) : Bool := + (((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true))) && (if ((_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (_root_.LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true))) && (if (((_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (_root_.LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) || (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool)) then (Bool.true && Bool.true) else (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true))))) + +theorem __rel_9 (byte : UInt8) : _root_.LexLeanPreservation.FunRel __prog 9 [(_root_.LexLeanTarget.TargetSyntax.Value.u8 byte)] (_root_.LexLeanPreservation.Rel (__fits_9 byte) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.isSpace byte))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => if __b then (Bool.true && Bool.true) else (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true)))) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (__b || ((_root_.LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) || (_root_.LexLeanRuntime.equal (byte) ((13 : UInt8)) : Bool)))) (((_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (_root_.LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) || (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool)) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => if __b then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true)) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (__b || (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool))) ((_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) || (_root_.LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool)) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => if __b then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true)) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (__b || (_root_.LexLeanRuntime.equal (byte) ((9 : UInt8)) : Bool))) (_root_.LexLeanRuntime.equal (byte) ((32 : UInt8)) : Bool) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (32 : UInt8))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_true)) (fun _ => (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (9 : UInt8))))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_true)) (fun _ => (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (10 : UInt8))))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_true)) (fun _ => (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => if __b then (Bool.true && Bool.true) else ((Bool.true && (Bool.true && Bool.true)) && Bool.true)) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (__b || (_root_.LexLeanRuntime.equal (byte) ((13 : UInt8)) : Bool))) (_root_.LexLeanRuntime.equal (byte) ((12 : UInt8)) : Bool) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (12 : UInt8))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_true)) (fun _ => (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (13 : UInt8))))))) + +def __fits_7 (subject : ByteArray) (position : Nat) : Bool := + (((Bool.true && (Bool.true && Bool.true)) && (__fits_8 (subject) (position))) && (match (LexLeanStd.Text.byteAt (subject) (position)) with | Option.some byte => ((Bool.true && Bool.true) && (__fits_9 (byte))) | Option.none => (Bool.true && Bool.true))) + +attribute [local irreducible] LexLeanStd.Text.byteAt LexLeanStd.Text.isSpace in +theorem __rel_7 (subject : ByteArray) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 7 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_7 subject position) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.spaceAt subject position))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (fun (__a : (Option UInt8)) => (match __a with | Option.some byte => ((Bool.true && Bool.true) && (__fits_9 (byte))) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option UInt8)) => _root_.LexLeanTarget.TargetSyntax.Value.bool (match __a with | Option.some byte => (LexLeanStd.Text.isSpace (byte)) | Option.none => Bool.false)) (LexLeanStd.Text.byteAt (subject) (position)) (_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_8 (subject) (position))) (fun (__a : (Option UInt8)) _ => match __a with | Option.some byte => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__rel_9 (byte)))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false))))) + +def __fits_5 (subject : ByteArray) («end» : Nat) : Bool := + (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.blt (0 : Nat) «end») then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && (__fits_7 (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)))) && (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then ((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) else (Bool.true && Bool.true))) + +attribute [local irreducible] LexLeanStd.Text.spaceAt in +theorem __rel_5 (subject : ByteArray) («end» : Nat) : _root_.LexLeanPreservation.FunRel __prog 5 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat «end»)] (_root_.LexLeanPreservation.Rel (__fits_5 subject «end») ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) ((if (Nat.blt (0 : Nat) «end») then (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && (__fits_7 (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)))) && (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then ((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))) (Nat.blt (0 : Nat) «end») (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLt (0 : Nat) «end»)) (fun _ => (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat)))) (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub «end» (1 : Nat))) _root_.LexLeanPreservation.convL_nil)) (__rel_7 (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)))) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub «end» (1 : Nat))) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) + +def __fits_1 (subject : ByteArray) : Bool := + (((Bool.true && Bool.true) && (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && Bool.true))) && (_root_.LexLeanPreservation.untilFits (fun (__p0 : Nat) => __fits_5 (subject) __p0) ((fun («end» : Nat) => (if (Nat.blt (0 : Nat) «end») then (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat))))) ((_root_.LexLeanRuntime.length (subject) : Nat)) ((_root_.LexLeanRuntime.length (subject) : Nat)))) + +attribute [local irreducible] LexLeanStd.Text.spaceAt in +theorem __rel_1 (subject : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 1 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (_root_.LexLeanPreservation.Rel (__fits_1 subject) (_root_.LexLeanTarget.TargetSyntax.Value.nat (LexLeanStd.Text.trimEnd subject))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_iterateUntil (es := _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.optEnc _root_.LexLeanTarget.TargetSyntax.Value.nat) (fun _ => rfl) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) (fun _ => rfl) ((fun («end» : Nat) => (if (Nat.blt (0 : Nat) «end») then (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat))))) (fun (__p0 : Nat) => __fits_5 (subject) __p0) 5 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (fun (__p0 : Nat) => __rel_5 (subject) __p0) (_root_.LexLeanCollections.iterateUntil ((fun («end» : Nat) => (if (Nat.blt (0 : Nat) «end») then (if (LexLeanStd.Text.spaceAt (subject) ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat))) then (Option.some ((_root_.LexLeanRuntime.subtract («end») ((1 : Nat)) : Nat)) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))))) (fun _ => rfl) (fun _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (fun _ _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (p := __prog) (fi := 4) (ts := .nat) rfl ((_root_.LexLeanRuntime.length (subject) : Nat)) ((_root_.LexLeanRuntime.length (subject) : Nat))))) + +def __fits_6 («end» : Nat) (subject : ByteArray) (start : Nat) : Bool := + (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.blt start «end») then (((Bool.true && (Bool.true && Bool.true)) && (__fits_7 (subject) (start))) && (if (LexLeanStd.Text.spaceAt (subject) (start)) then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (start + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) else (Bool.true && Bool.true))) + +attribute [local irreducible] LexLeanStd.Text.spaceAt in +theorem __rel_6 («end» : Nat) (subject : ByteArray) (start : Nat) : _root_.LexLeanPreservation.FunRel __prog 6 [(_root_.LexLeanTarget.TargetSyntax.Value.nat «end»), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat start)] (_root_.LexLeanPreservation.Rel (__fits_6 «end» subject start) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) ((if (Nat.blt start «end») then (if (LexLeanStd.Text.spaceAt (subject) (start)) then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then (((Bool.true && (Bool.true && Bool.true)) && (__fits_7 (subject) (start))) && (if (LexLeanStd.Text.spaceAt (subject) (start)) then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (start + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (if (LexLeanStd.Text.spaceAt (subject) (start)) then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))) (Nat.blt start «end») (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLt start «end»)) (fun _ => (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (start + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))) (LexLeanStd.Text.spaceAt (subject) (start)) (_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_7 (subject) (start))) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd start (1 : Nat))) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))) + +def __fits_2 (subject : ByteArray) («end» : Nat) : Bool := + (((Bool.true && (Bool.true && Bool.true)) && (Bool.true && (Bool.true && Bool.true))) && (_root_.LexLeanPreservation.untilFits (fun (__p0 : Nat) => __fits_6 («end») (subject) __p0) ((fun (start : Nat) => (if (Nat.blt start «end») then (if (LexLeanStd.Text.spaceAt (subject) (start)) then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat))))) («end») ((0 : Nat)))) + +attribute [local irreducible] LexLeanStd.Text.spaceAt in +theorem __rel_2 (subject : ByteArray) («end» : Nat) : _root_.LexLeanPreservation.FunRel __prog 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat «end»)] (_root_.LexLeanPreservation.Rel (__fits_2 subject «end») (_root_.LexLeanTarget.TargetSyntax.Value.nat (LexLeanStd.Text.trimStart subject «end»))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_iterateUntil (es := _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.optEnc _root_.LexLeanTarget.TargetSyntax.Value.nat) (fun _ => rfl) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) (fun _ => rfl) ((fun (start : Nat) => (if (Nat.blt start «end») then (if (LexLeanStd.Text.spaceAt (subject) (start)) then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat))))) (fun (__p0 : Nat) => __fits_6 («end») (subject) __p0) 6 [(_root_.LexLeanTarget.TargetSyntax.Value.nat «end»), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (fun (__p0 : Nat) => __rel_6 («end») (subject) __p0) (_root_.LexLeanCollections.iterateUntil ((fun (start : Nat) => (if (Nat.blt start «end») then (if (LexLeanStd.Text.spaceAt (subject) (start)) then (Option.some ((start + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))) else (Option.none : (Option Nat)))))) (fun _ => rfl) (fun _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (fun _ _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (p := __prog) (fi := 4) (ts := .nat) rfl («end») ((0 : Nat))))) + +def __fits_3 (subject : ByteArray) (start : Nat) (count : Nat) : Bool := + (((Bool.true && (Bool.true && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) with | Option.some piece => Bool.true | Option.none => Bool.true)) + +theorem __rel_3 (subject : ByteArray) (start : Nat) (count : Nat) : _root_.LexLeanPreservation.FunRel __prog 3 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat start), (_root_.LexLeanTarget.TargetSyntax.Value.nat count)] (_root_.LexLeanPreservation.Rel (__fits_3 subject start count) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.sliceOr subject start count))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some piece => Bool.true | Option.none => Bool.true)) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bytes (match __a with | Option.some piece => piece | Option.none => (ByteArray.mk #[]))) (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_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))) (_root_.LexLeanPreservation.prim_slice_bytes subject start count)) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some piece => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_var rfl)) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl _root_.LexLeanPreservation.conv_value)))) + +def __fits_0 (subject : ByteArray) : Bool := + (((Bool.true && Bool.true) && (__fits_1 (subject))) && (let «end» : Nat := (LexLeanStd.Text.trimEnd (subject)); (((Bool.true && (Bool.true && Bool.true)) && (__fits_2 (subject) («end»))) && (let start : Nat := (LexLeanStd.Text.trimStart (subject) («end»)); ((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_3 (subject) (start) ((_root_.LexLeanRuntime.subtract («end») (start) : Nat)))))))) + +attribute [local irreducible] LexLeanStd.Text.sliceOr LexLeanStd.Text.trimEnd LexLeanStd.Text.trimStart in +theorem __rel_0 (subject : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (let «end» : Nat := (LexLeanStd.Text.trimEnd (subject)); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__rel_1 (subject))) (let start : Nat := (LexLeanStd.Text.trimStart (subject) («end»)); _root_.LexLeanPreservation.conv_let (_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_2 (subject) («end»))) (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub «end» start)) _root_.LexLeanPreservation.convL_nil))) (__rel_3 (subject) (start) ((_root_.LexLeanRuntime.subtract («end») (start) : Nat)))))) + +def denote (subject : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject) (_root_.LexLeanPreservation.Obs.value ((_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.trim subject)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..e57634ced7 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/Compose/RustStd.lex.tex @@ -0,0 +1,418 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.root : @826 := @827 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.flags +@3 := ByteArray +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (b : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@57 := Nat +@60 := Prod.{0, 0} @57 @50 +@61 := 0 +@65 := Prod.mk.{0, 0} @57 @50 @61 +@66 := @65 @6 +@67 := @51 @60 +@68 := @52 @60 +@70 := @68 @66 @67 +@71 := Bool.true +@72 := LexLeanTarget.TargetSyntax.Function +@73 := LexLeanTarget.TargetSyntax.Program.functions +@74 := @73 @0 +@75 := LexLeanTarget.TargetSyntax.Ty +@76 := @51 @57 +@77 := @51 @75 +@78 := LexLeanTarget.TargetSyntax.Ty.unit +@79 := LexLeanTarget.TargetSyntax.Value.unit +@82 := LexLeanTarget.TargetSyntax.Expr.value @78 @79 +@87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 +@92 := List.getD.{0} @72 @74 @61 @87 +@96 := fun (__e_n : @57) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@108 := @97 @0 +@114 := {c : @9} -> {A : @10} -> @108 @4 @17 @53 @77 +@115 := @107 @1 +@116 := @108 @1 +@120 := {A : @10} -> @116 @17 @53 @77 +@121 := @115 @2 +@122 := @116 @2 +@123 := @122 @53 +@124 := @123 @77 +@125 := List.{0} +@126 := @125 @50 +@127 := @125 @75 +@128 := #6 +@129 := @11 @128 +@130 := #5 +@131 := @129 @130 +@132 := #4 +@135 := @131 @132 @12 @14 +@136 := #7 +@141 := @97 @136 @128 @130 @14 @4 +@142 := #8 +@145 := @97 @142 @136 @128 +@147 := @54 @130 @12 +@148 := @145 @147 +@149 := @52 @75 +@151 := @149 @132 @14 +@161 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @135) -> (hs : @141) -> @148 @151 +@163 := LexLeanPreservation.Rust.wtl_cons @0 +@183 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> + (h : @27 @130 @132 @12 @14) -> (hs : @108 @128 @130 @14 @4) -> @108 @136 @128 @147 @151 +@184 := @163 @1 +@200 := {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> (h : @36 @132 @12 @14) -> (hs : @116 @130 @14 @4) -> @116 @128 @147 @151 +@201 := @184 @2 +@203 := @43 @12 @14 +@205 := @122 @14 @4 +@213 := {v : @50} -> + {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @203) -> (hs : @205) -> @122 @147 @151 +@214 := @201 @6 +@215 := @5 @132 +@217 := @43 @215 @14 +@218 := @5 @128 +@219 := @54 @218 +@227 := {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @217) -> (hs : @205) -> @122 (@219 @12) @151 +@228 := @214 @7 +@229 := @5 @12 +@231 := @43 @229 @7 +@232 := @5 @130 +@233 := @54 @232 +@235 := @122 (@233 @12) +@236 := @149 @7 +@237 := @236 @14 +@242 := {vs : @126} -> {ts : @127} -> (h : @231) -> (hs : @205) -> @235 @237 +@243 := @228 @53 +@244 := @5 @14 +@246 := @43 @244 @7 +@247 := @123 @4 +@249 := @54 @215 @53 +@250 := @122 @249 +@254 := {ts : @127} -> (h : @246) -> (hs : @247) -> @250 @237 +@255 := @243 @77 +@257 := @54 @229 @53 +@258 := @122 @257 +@259 := @236 @77 +@262 := (h : @49) -> (hs : @124) -> @258 @259 +@263 := @255 @47 +@265 := @54 @244 @53 +@266 := @122 @265 +@268 := (hs : @124) -> @266 @259 +@269 := @263 @121 +@270 := @122 @56 +@271 := @270 @259 +@272 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.denote +@273 := @272 @4 +@274 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.__fits_0 +@275 := @274 @4 +@278 := @5 (LexLeanStd.Text.trim @4) +@280 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.root @4 +@281 := Bool +@282 := Ne.{1} +@283 := LexLeanPreservation.Obs +@284 := @282 @283 +@285 := LexLeanPreservation.Rel +@288 := @284 (@285 @4 @17) +@289 := LexLeanPreservation.Obs.stuck +@292 := (f : @281) -> (v : @50) -> @288 @289 +@294 := LexLeanPreservation.Rust.rel_ne_stuck @275 +@300 := (v : @50) -> @284 (@285 (@274 @14) @17) @289 +@301 := @294 @278 +@305 := @284 (@285 @275 @278) @289 +@306 := @125 @60 +@307 := LexLeanPreservation.Rust.FunSem +@308 := #9 +@314 := (n : @57) -> @307 @308 @142 @136 @17 @128 +@315 := Eq.{1} +@316 := Option.{0} +@317 := @316 @72 +@318 := @315 @317 +@325 := LexLeanRuntime.index (@125 @72) @72 (LexLeanRuntime.instIndexableList @72) +@329 := @318 (@325 (@73 @308) @128) +@330 := Option.some.{0} +@331 := @330 @72 +@332 := @331 @130 +@333 := @329 @332 +@334 := #10 +@338 := @97 @334 @308 @142 @130 +@339 := LexLeanTarget.TargetSyntax.Function.types +@340 := @339 @128 +@341 := @338 @340 +@342 := @316 @306 +@343 := @315 @342 +@344 := LexLeanTarget.TargetSemantics.bindAll +@345 := LexLeanTarget.TargetSyntax.Function.parameters +@350 := @343 (@344 (@345 @136) @128 @67) +@351 := @330 @306 +@352 := @351 @130 +@353 := @350 @352 +@354 := @316 @281 +@355 := @315 @354 +@356 := LexLeanPreservation.Rust.fnFallible +@357 := #11 +@360 := @355 (@356 @357 @308) +@361 := @330 @281 +@362 := @361 @130 +@363 := @360 @362 +@364 := LexLeanPreservation.RunConv +@365 := #13 +@369 := @364 @365 @334 @142 @130 +@371 := @284 @128 @289 +@372 := Exists.{1} +@373 := LexLeanPreservation.Rust.ROut +@374 := @372 @373 +@375 := And +@376 := LexLeanPreservation.Rust.RealizesFn +@380 := @375 (@376 @308 @142 @17) +@381 := LexLeanPreservation.Rust.RCI +@383 := @381 #15 +@384 := LexLeanPreservation.Rust.fnIdent +@385 := @384 @365 +@392 := (hne : @371) -> @374 (fun (ro : @373) => @380 (@383 @385 @357 @17)) +@407 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @314) -> + (hfn : @333) -> (hwt : @341) -> (hbind : @353) -> (hF : @363) -> (hA : @369) -> @392 +@409 := LexLeanPreservation.Rust.compose @0 +@410 := @307 @0 +@415 := (n : @57) -> @410 @142 @136 @17 @128 +@416 := @325 @74 +@419 := @318 (@416 @128) @332 +@423 := @108 @308 @142 @130 @340 +@424 := @364 @0 +@427 := @424 @334 @142 @130 +@441 := {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @415) -> + (hfn : @419) -> (hwt : @423) -> (hbind : @353) -> (hF : @363) -> (hA : @427) -> @392 +@442 := @409 @1 +@443 := @410 @1 +@447 := (n : @57) -> @443 @136 @17 @128 +@450 := @116 @142 @130 @340 +@451 := @356 @1 +@454 := @355 (@451 @308) @362 +@455 := @381 @1 +@465 := (hbind : @353) -> + (hF : @454) -> (hA : @427) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@455 @385 @357 @17)) +@475 := {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @447) -> (hfn : @419) -> (hwt : @450) -> @465 +@476 := @442 @2 +@478 := @443 @2 @17 +@480 := (n : @57) -> @478 @128 +@481 := @122 @130 +@482 := @481 @340 +@491 := {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @306} -> {F : @281} -> {o : @283} -> (hB : @480) -> (hfn : @419) -> (hwt : @482) -> @465 +@492 := @476 @61 +@494 := (n : @57) -> @478 @61 +@495 := @416 @61 +@496 := @318 @495 +@497 := @496 @332 +@498 := @451 @61 +@499 := @355 @498 +@500 := @499 @362 +@501 := @424 @61 +@503 := @501 @142 @130 +@505 := @455 (@384 @61) +@513 := (hF : @500) -> (hA : @503) -> (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 @357 @17)) +@522 := {fn : @72} -> + {args : @126} -> + {env : @306} -> + {F : @281} -> {o : @283} -> (hB : @494) -> (hfn : @497) -> (hwt : @482) -> (hbind : @353) -> @513 +@523 := @492 @92 +@525 := @496 (@331 @92) +@526 := @339 @92 +@527 := @481 @526 +@529 := @344 (@345 @92) +@541 := {args : @126} -> + {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> (hfn : @525) -> (hwt : @527) -> (hbind : @343 (@529 @128 @67) @352) -> @513 +@542 := @523 @56 +@543 := @219 @53 +@545 := @122 @543 @526 +@548 := @54 (@5 @136) @53 +@552 := @343 (@529 @548 @67) @352 +@555 := @54 (@5 @308) @53 +@576 := {env : @306} -> + {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @545) -> + (hbind : @552) -> + (hF : @500) -> + (hA : @501 @555 @130) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 #12) @53) @17)) +@577 := @542 @70 +@578 := @233 @53 +@580 := @122 @578 @526 +@588 := @343 (@529 @543 @67) (@351 (@68 (@65 @218) @67)) +@591 := @54 (@5 @142) @53 +@610 := {F : @281} -> + {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @580) -> + (hbind : @588) -> + (hF : @500) -> + (hA : @501 @591 @130) -> + (hne : @371) -> @374 (fun (ro : @373) => @380 (@505 (@54 (@5 @357) @53) @17)) +@611 := @577 @71 +@612 := @250 @526 +@620 := @343 (@529 @578 @67) (@351 (@68 (@65 @232) @67)) +@622 := @499 (@361 @71) +@624 := @501 @548 @130 +@625 := @376 @71 +@644 := {o : @283} -> + (hB : @494) -> + (hfn : @525) -> + (hwt : @612) -> + (hbind : @620) -> + (hF : @622) -> + (hA : @624) -> + (hne : @371) -> @374 (fun (ro : @373) => @375 (@625 @142 @17) (@505 (@54 (@5 @334) @53) @17)) +@645 := @611 @273 +@646 := @258 @526 +@654 := @343 (@529 @249 @67) (@351 (@68 (@65 @215) @67)) +@655 := @501 @543 +@656 := @272 @128 +@657 := @655 @656 +@658 := @272 @136 +@676 := (hB : @494) -> + (hfn : @525) -> + (hwt : @646) -> + (hbind : @654) -> + (hF : @622) -> + (hA : @657) -> + (hne : @284 @658 @289) -> @374 (fun (ro : @373) => @375 (@625 (@272 @308) @17) (@505 @555 @17)) +@677 := @645 @96 +@678 := @266 @526 +@686 := @343 (@529 @257 @67) (@351 (@68 (@65 @229) @67)) +@687 := @501 @578 +@688 := @272 @130 +@706 := (hfn : @525) -> + (hwt : @678) -> + (hbind : @686) -> + (hF : @622) -> + (hA : @687 @688) -> + (hne : @284 @656 @289) -> @374 (fun (ro : @373) => @375 (@625 (@272 @142) @17) (@505 @591 @17)) +@707 := Eq.refl.{1} +@710 := @677 (@707 @317 @495) +@711 := @270 @526 +@719 := @343 (@529 @265 @67) (@351 (@68 (@65 @244) @67)) +@720 := @501 @249 +@721 := @272 @132 +@737 := (hwt : @711) -> + (hbind : @719) -> + (hF : @622) -> + (hA : @720 @721) -> + (hne : @284 @688 @289) -> @374 (fun (ro : @373) => @375 (@625 @658 @17) (@505 @548 @17)) +@738 := @710 @269 +@740 := @529 @56 @67 +@743 := @343 @740 (@351 @70) +@744 := @501 @257 +@745 := @272 @12 +@760 := (hbind : @743) -> + (hF : @622) -> + (hA : @744 @745) -> + (hne : @284 @721 @289) -> @374 (fun (ro : @373) => @375 (@625 @656 @17) (@505 @543 @17)) +@763 := @738 (@707 @342 @740) +@764 := @501 @265 +@765 := @272 @14 +@779 := (hF : @622) -> + (hA : @764 @765) -> + (hne : @284 @745 @289) -> @374 (fun (ro : @373) => @375 (@625 @688 @17) (@505 @578 @17)) +@782 := @763 (@707 @354 @498) +@796 := (hA : @501 @56 @273) -> + (hne : @284 @765 @289) -> @374 (fun (ro : @373) => @375 (@625 @721 @17) (@505 @249 @17)) +@797 := @782 @280 +@808 := (hne : @284 @273 @289) -> @374 (fun (ro : @373) => @375 (@625 @745 @17) (@505 @257 @17)) +@809 := @797 @301 +@815 := @375 (@625 @765 @17) (@505 @265 @17) +@817 := @374 (fun (ro : @373) => @815) +@819 := @374 (fun (__e_ro : @373) => @815) +@823 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@824 := (__e_hrep : @823) -> @819 +@825 := fun (__e_hrep : @823) => @809 +@826 := (subject : @3) -> @824 +@827 := fun (subject : @3) => @825 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/RustStd.lean new file mode 100644 index 0000000000..7c840859cd --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/RustStd.lean @@ -0,0 +1,107 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0], types := [.bytes], result := .bytes, + body := (.«let» 1 .nat (.call 1 [(.var 0)]) (.«let» 2 .nat (.call 2 [(.var 0), (.var 1)]) (.call 3 [(.var 0), (.var 2), (.prim .natSub [(.var 1), (.var 2)])]))) }, + { parameters := [0], types := [.bytes], result := .nat, + body := (.first (.call 4 [(.closure 5 [(.var 0)]), (.prim .length [(.var 0)]), (.prim .length [(.var 0)])])) }, + { parameters := [0, 1], types := [.bytes, .nat], result := .nat, + body := (.first (.call 4 [(.closure 6 [(.var 1), (.var 0)]), (.var 1), (.value .nat (.nat 0))])) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [(.fn [.nat] (.option .nat)), .nat, .nat], result := (.pair .nat .bool), + body := (.«match» (.pair .nat .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair .nat .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 4 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option .nat), + body := (.cond (.prim .natLt [(.value .nat (.nat 0)), (.var 1)]) (.cond (.call 7 [(.var 0), (.prim .natSub [(.var 1), (.value .nat (.nat 1))])]) (.build .some (.option .nat) [(.prim .natSub [(.var 1), (.value .nat (.nat 1))])]) (.build .none (.option .nat) [])) (.build .none (.option .nat) [])) }, + { parameters := [0, 1, 2], types := [.nat, .bytes, .nat], result := (.option .nat), + body := (.cond (.prim .natLt [(.var 2), (.var 0)]) (.cond (.call 7 [(.var 1), (.var 2)]) (.build .some (.option .nat) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))])]) (.build .none (.option .nat) [])) (.build .none (.option .nat) [])) }, + { parameters := [0, 1], types := [.bytes, .nat], result := .bool, + body := (.«match» .bool (.call 8 [(.var 0), (.var 1)]) [(.arm .some [2] (.call 9 [(.var 2)])), (.arm .none [] (.build .false .bool []))]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }, + { parameters := [0], types := [(.fixed .u8)], result := .bool, + body := (.cond (.cond (.cond (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 32))]) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 9))])) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 10))])) (.build .true .bool []) (.cond (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 12))]) (.build .true .bool []) (.prim .equal [(.var 0), (.value (.fixed .u8) (.u8 13))]))) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.enum (.fn 0) [{ number := 5, fields := [.bytes] }, { number := 6, fields := [.nat, .bytes] }]), + (.apply 0 [.nat] (.option .nat) true [{ function := 5, captures := [.clone], functionFallible := false }, { function := 6, captures := [.copy, .clone], functionFallible := true }]), + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }] (.fallible .bytes) (.mk [(.mk (.bind (.generated .binding 1)) (some .nat) (.call (.function 1) [(.clone (.generated .binding 0))] true)), (.mk (.bind (.generated .binding 2)) (some .nat) (.call (.function 2) [(.clone (.generated .binding 0)), (.copy (.generated .binding 1))] true))] (.succeed (.call (.function 3) [(.move (.generated .binding 0)), (.copy (.generated .binding 2)), (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 2)) none (.copy (.generated .binding 2)))] (.call (.runtime .natSub) [(.move (.generated .operand 1)), (.move (.generated .operand 2))] false)))] false)))), + (.function (.generated .function 1) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }] (.fallible .nat) (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.call (.function 4) [(.construct (.closure 0 5) [(.clone (.generated .binding 0))]), (.block (.mk [(.mk (.bind (.generated .operand 4)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 4))] false))), (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 5))] false)))] true))] (.succeed (.move (.generated .part 3))))), + (.function (.generated .function 2) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] (.fallible .nat) (.mk [(.mk (.tuple [(.bind (.generated .part 6)), .wild]) none (.call (.function 4) [(.construct (.closure 0 6) [(.copy (.generated .binding 1)), (.move (.generated .binding 0))]), (.copy (.generated .binding 1)), (.lit (.nat 0))] true))] (.succeed (.move (.generated .part 6))))), + (.function (.generated .function 3) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .nat }] .bytes (.mk [(.mk (.bind (.generated .holder 10)) none (.block (.mk [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false))))] (.matchOn (.move (.generated .holder 10)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]))), + (.function (.generated .function 4) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 0) }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .nat }] (.fallible (.pair .nat .bool)) (.mk [(.mk (.bind (.generated .holder 11)) none (.copy (.generated .binding 1)))] (.cond (.isZero (.generated .holder 11)) (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 11))), (.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.copy (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))]))))), + (.function (.generated .function 5) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] (.option .nat) (.mk [(.mk (.bind (.generated .operand 14)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1)))] (.cond (.call (.runtime .natLt) [(.move (.generated .operand 14)), (.move (.generated .operand 15))] false) (.mk [] (.cond (.call (.function 7) [(.move (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 17)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 16)), (.move (.generated .operand 17))] false)))] false) (.mk [] (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 18)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 19)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 18)), (.move (.generated .operand 19))] false)))])) (.mk [] (.construct (.none .nat) [])))) (.mk [] (.construct (.none .nat) []))))), + (.function (.generated .function 6) [{ pattern := (.bind (.generated .binding 0)), type := .nat }, { pattern := (.bind (.generated .binding 1)), type := .bytes }, { pattern := (.bind (.generated .binding 2)), type := .nat }] (.fallible (.option .nat)) (.mk [(.mk (.bind (.generated .operand 20)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 21)) none (.copy (.generated .binding 0)))] (.cond (.call (.runtime .natLt) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false) (.mk [] (.cond (.call (.function 7) [(.move (.generated .binding 1)), (.copy (.generated .binding 2))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 23)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) []))))) (.mk [] (.succeed (.construct (.none .nat) [])))))), + (.function (.generated .function 7) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] .bool (.mk [(.mk (.bind (.generated .holder 24)) none (.call (.function 8) [(.move (.generated .binding 0)), (.copy (.generated .binding 1))] false))] (.matchOn (.move (.generated .holder 24)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 2))) (.mk [] (.call (.function 9) [(.copy (.generated .binding 2))] false)))]))), + (.function (.generated .function 8) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] (.option (.fixed .u8)) (.mk [(.mk (.bind (.generated .operand 25)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 1)))] (.call (.runtime .indexBytes) [(.move (.generated .operand 25)), (.move (.generated .operand 26))] false))), + (.function (.generated .function 9) [{ pattern := (.bind (.generated .binding 0)), type := (.fixed .u8) }] .bool (.mk [(.mk (.bind (.generated .operand 27)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 28)) none (.lit (.fixed .u8 32)))] (.cond (.cond (.cond (.call (.runtime .equal) [(.move (.generated .operand 27)), (.move (.generated .operand 28))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 30)) none (.lit (.fixed .u8 9)))] (.call (.runtime .equal) [(.move (.generated .operand 29)), (.move (.generated .operand 30))] false))) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 32)) none (.lit (.fixed .u8 10)))] (.call (.runtime .equal) [(.move (.generated .operand 31)), (.move (.generated .operand 32))] false))) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 33)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 34)) none (.lit (.fixed .u8 12)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 33)), (.move (.generated .operand 34))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 36)) none (.lit (.fixed .u8 13)))] (.call (.runtime .equal) [(.move (.generated .operand 35)), (.move (.generated .operand 36))] false)))))))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [(([.nat], (.option .nat)), true)] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 1)) (some .nat) (.call (.function 1) [(.clone (.generated .binding 0))] true)), (.mk (.bind (.generated .binding 2)) (some .nat) (.call (.function 2) [(.clone (.generated .binding 0)), (.copy (.generated .binding 1))] true))], (.succeed (.call (.function 3) [(.move (.generated .binding 0)), (.copy (.generated .binding 2)), (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 2)) none (.copy (.generated .binding 2)))] (.call (.runtime .natSub) [(.move (.generated .operand 1)), (.move (.generated .operand 2))] false)))] false)), [(0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfBNil (Corr.callOps (ts := [.bytes]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl)) rfl (Corr.fOfB (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 2)) none (.copy (.generated .binding 2)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 1)), (.move (.generated .operand 2))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl))))⟩⟩ + +theorem fun1 : FunOK program krate flags 1 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.call (.function 4) [(.construct (.closure 0 5) [(.clone (.generated .binding 0))]), (.block (.mk [(.mk (.bind (.generated .operand 4)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 4))] false))), (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 5))] false)))] true))], (.succeed (.move (.generated .part 3))), [(0, .bytes, (some 0))], rfl, rfl, + (Corr.fOfB (Corr.first (ta := .nat) (tb := .bool) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [.nat] (.option .nat)), .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [.bytes]) (mask := [false]) (af := true) (ff := false) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 4)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 4))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 5))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl))⟩⟩ + +theorem fun2 : FunOK program krate flags 2 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.tuple [(.bind (.generated .part 6)), .wild]) none (.call (.function 4) [(.construct (.closure 0 6) [(.copy (.generated .binding 1)), (.move (.generated .binding 0))]), (.copy (.generated .binding 1)), (.lit (.nat 0))] true))], (.succeed (.move (.generated .part 6))), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.fOfB (Corr.first (ta := .nat) (tb := .bool) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [.nat] (.option .nat)), .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [.nat, .bytes]) (mask := [false, false]) (af := true) (ff := true) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.value rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl))⟩⟩ + +theorem fun3 : FunOK program krate flags 3 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 10)) none (.block (.mk [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false))))], (.matchOn (.move (.generated .holder 10)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]), [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 7)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 2)))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8)), (.move (.generated .operand 9))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bytes (ByteArray.mk #[])))) (Corr.mCons (Γ' := [(3, .bytes, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 3))) (Corr.mNil) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl (Corr.bOfE (Corr.value rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun4 : FunOK program krate flags 4 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 11)) none (.copy (.generated .binding 1)))], (.cond (.isZero (.generated .holder 11)) (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 11))), (.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.copy (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))]))), [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))], rfl, rfl, + (Corr.matchNat (sl := (some 3)) (Corr.var rfl rfl) rfl rfl rfl (Corr.kIf (la := []) (ta := (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (lb := [(.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.copy (.generated .binding 2))] true))))]) (tb := (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))])) (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil)))))) (Corr.matchArms (st := (.option .nat)) (U := []) (view := false) (idx := [0, 1]) (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))]) (tail := (.apply (.generated .callee 12) [(.copy (.generated .binding 2))] true)) (Corr.apply (ps := [.nat]) (af := true) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true))))) (Corr.mCons (Γ' := [(4, .nat, (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callF (ts := [(.fn [.nat] (.option .nat)), .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl)) rfl rfl rfl (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil))))))) rfl rfl rfl)))⟩⟩ + +theorem fun5 : FunOK program krate flags 5 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 14)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1)))], (.cond (.call (.runtime .natLt) [(.move (.generated .operand 14)), (.move (.generated .operand 15))] false) (.mk [] (.cond (.call (.function 7) [(.move (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 17)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 16)), (.move (.generated .operand 17))] false)))] false) (.mk [] (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 18)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 19)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 18)), (.move (.generated .operand 19))] false)))])) (.mk [] (.construct (.none .nat) [])))) (.mk [] (.construct (.none .nat) []))), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.cond (lc := [(.mk (.bind (.generated .operand 14)) none (.lit (.nat 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1)))]) (ce := (.call (.runtime .natLt) [(.move (.generated .operand 14)), (.move (.generated .operand 15))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.cond (.call (.function 7) [(.move (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 17)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 16)), (.move (.generated .operand 17))] false)))] false) (.mk [] (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 18)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 19)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 18)), (.move (.generated .operand 19))] false)))])) (.mk [] (.construct (.none .nat) [])))) (lb := []) (tb := (.construct (.none .nat) [])) (Corr.cond (lc := []) (ce := (.call (.function 7) [(.move (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 17)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 16)), (.move (.generated .operand 17))] false)))] false)) (lk := []) (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 17)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 16)), (.move (.generated .operand 17))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil)))) rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 18)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 19)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 18)), (.move (.generated .operand 19))] false)))])) (lb := []) (tb := (.construct (.none .nat) [])) (Corr.build (ts := [.nat]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 18)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 19)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 18)), (.move (.generated .operand 19))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))) rfl) (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl))) (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)))⟩⟩ + +theorem fun6 : FunOK program krate flags 6 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 20)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 21)) none (.copy (.generated .binding 0)))], (.cond (.call (.runtime .natLt) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false) (.mk [] (.cond (.call (.function 7) [(.move (.generated .binding 1)), (.copy (.generated .binding 2))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 23)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) []))))) (.mk [] (.succeed (.construct (.none .nat) [])))), [(2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .nat, (some 0))], rfl, rfl, + (Corr.cond (lc := [(.mk (.bind (.generated .operand 20)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 21)) none (.copy (.generated .binding 0)))]) (ce := (.call (.runtime .natLt) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.cond (.call (.function 7) [(.move (.generated .binding 1)), (.copy (.generated .binding 2))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 23)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) []))))) (lb := []) (tb := (.succeed (.construct (.none .nat) []))) (Corr.cond (lc := []) (ce := (.call (.function 7) [(.move (.generated .binding 1)), (.copy (.generated .binding 2))] false)) (lk := []) (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 23)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] true)))]))) (lb := []) (tb := (.succeed (.construct (.none .nat) []))) (Corr.fOfB (Corr.build (ts := [.nat]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 23)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))) rfl)) (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)))) (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl))))⟩⟩ + +theorem fun7 : FunOK program krate flags 7 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 24)) none (.call (.function 8) [(.move (.generated .binding 0)), (.copy (.generated .binding 1))] false))], (.matchOn (.move (.generated .holder 24)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 2))) (.mk [] (.call (.function 9) [(.copy (.generated .binding 2))] false)))]), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option (.fixed .u8))) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bool false))) (Corr.mCons (Γ' := [(2, (.fixed .u8), (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.call (.function 9) [(.copy (.generated .binding 2))] false)) (Corr.mNil) rfl rfl rfl (Corr.callOps (ts := [(.fixed .u8)]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.buildConst rfl))) rfl rfl rfl)⟩⟩ + +theorem fun8 : FunOK program krate flags 8 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 25)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 1)))], (.call (.runtime .indexBytes) [(.move (.generated .operand 25)), (.move (.generated .operand 26))] false), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.prim (ts := [.bytes, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)⟩⟩ + +theorem fun9 : FunOK program krate flags 9 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 27)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 28)) none (.lit (.fixed .u8 32)))], (.cond (.cond (.cond (.call (.runtime .equal) [(.move (.generated .operand 27)), (.move (.generated .operand 28))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 30)) none (.lit (.fixed .u8 9)))] (.call (.runtime .equal) [(.move (.generated .operand 29)), (.move (.generated .operand 30))] false))) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 32)) none (.lit (.fixed .u8 10)))] (.call (.runtime .equal) [(.move (.generated .operand 31)), (.move (.generated .operand 32))] false))) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 33)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 34)) none (.lit (.fixed .u8 12)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 33)), (.move (.generated .operand 34))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 36)) none (.lit (.fixed .u8 13)))] (.call (.runtime .equal) [(.move (.generated .operand 35)), (.move (.generated .operand 36))] false))))), [(0, (.fixed .u8), (some 0))], rfl, rfl, + (Corr.cond (lc := [(.mk (.bind (.generated .operand 27)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 28)) none (.lit (.fixed .u8 32)))]) (ce := (.cond (.cond (.call (.runtime .equal) [(.move (.generated .operand 27)), (.move (.generated .operand 28))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 30)) none (.lit (.fixed .u8 9)))] (.call (.runtime .equal) [(.move (.generated .operand 29)), (.move (.generated .operand 30))] false))) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 32)) none (.lit (.fixed .u8 10)))] (.call (.runtime .equal) [(.move (.generated .operand 31)), (.move (.generated .operand 32))] false)))) (lk := []) (Corr.cond (lc := [(.mk (.bind (.generated .operand 27)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 28)) none (.lit (.fixed .u8 32)))]) (ce := (.cond (.call (.runtime .equal) [(.move (.generated .operand 27)), (.move (.generated .operand 28))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 30)) none (.lit (.fixed .u8 9)))] (.call (.runtime .equal) [(.move (.generated .operand 29)), (.move (.generated .operand 30))] false)))) (lk := []) (Corr.cond (lc := [(.mk (.bind (.generated .operand 27)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 28)) none (.lit (.fixed .u8 32)))]) (ce := (.call (.runtime .equal) [(.move (.generated .operand 27)), (.move (.generated .operand 28))] false)) (lk := []) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.lit (.bool true))) (lb := [(.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 30)) none (.lit (.fixed .u8 9)))]) (tb := (.call (.runtime .equal) [(.move (.generated .operand 29)), (.move (.generated .operand 30))] false)) (Corr.bOfE (Corr.buildConst rfl)) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl))) (Corr.kIf (la := []) (ta := (.lit (.bool true))) (lb := [(.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 32)) none (.lit (.fixed .u8 10)))]) (tb := (.call (.runtime .equal) [(.move (.generated .operand 31)), (.move (.generated .operand 32))] false)) (Corr.bOfE (Corr.buildConst rfl)) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl))) (Corr.kIf (la := []) (ta := (.lit (.bool true))) (lb := [(.mk (.bind (.generated .operand 33)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 34)) none (.lit (.fixed .u8 12)))]) (tb := (.cond (.call (.runtime .equal) [(.move (.generated .operand 33)), (.move (.generated .operand 34))] false) (.mk [] (.lit (.bool true))) (.mk [(.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 36)) none (.lit (.fixed .u8 13)))] (.call (.runtime .equal) [(.move (.generated .operand 35)), (.move (.generated .operand 36))] false)))) (Corr.bOfE (Corr.buildConst rfl)) (Corr.cond (lc := [(.mk (.bind (.generated .operand 33)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 34)) none (.lit (.fixed .u8 12)))]) (ce := (.call (.runtime .equal) [(.move (.generated .operand 33)), (.move (.generated .operand 34))] false)) (lk := []) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.lit (.bool true))) (lb := [(.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 0))), (.mk (.bind (.generated .operand 36)) none (.lit (.fixed .u8 13)))]) (tb := (.call (.runtime .equal) [(.move (.generated .operand 35)), (.move (.generated .operand 36))] false)) (Corr.bOfE (Corr.buildConst rfl)) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)))))⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | 1 => exact fun1 + | 2 => exact fun2 + | 3 => exact fun3 + | 4 => exact fun4 + | 5 => exact fun5 + | 6 => exact fun6 + | 7 => exact fun7 + | 8 => exact fun8 + | 9 => exact fun9 + | _ + 10 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3.lean new file mode 100644 index 0000000000..400a3fdb3c --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3.lean @@ -0,0 +1,88 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, (.fixed .u8)], result := (.list .bytes), + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 (.pair .nat (.pair .nat (.list .bytes))) (.first (.call 1 [(.closure 2 [(.var 1), (.var 0)]), (.var 2), (.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.value .nat (.nat 0)), (.build .pair (.pair .nat (.list .bytes)) [(.value .nat (.nat 0)), (.build .nil (.list .bytes) [])])])])) (.«let» 4 .nat (.first (.second (.var 3))) (.call 3 [(.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 4), (.prim .natSub [(.var 2), (.var 4)])]), (.second (.second (.var 3)))])])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))], result := (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool), + body := (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1, 2], types := [(.fixed .u8), .bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.call 5 [(.var 1), (.var 0), (.var 2)]) }, + { parameters := [0], types := [(.list .bytes)], result := (.list .bytes), + body := (.call 6 [(.closure 7 []), (.build .nil (.list .bytes) []), (.var 0)]) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [.bytes, (.fixed .u8), (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.«let» 3 .nat (.first (.var 2)) (.«let» 4 .nat (.first (.second (.var 2))) (.«let» 5 (.list .bytes) (.second (.second (.var 2))) (.«match» (.option (.pair .nat (.pair .nat (.list .bytes)))) (.call 8 [(.var 0), (.var 3)]) [(.arm .some [6] (.cond (.prim .equal [(.var 6), (.var 1)]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 4), (.prim .natSub [(.var 3), (.var 4)])]), (.var 5)])])])]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.var 4), (.var 5)])])]))), (.arm .none [] (.build .none (.option (.pair .nat (.pair .nat (.list .bytes)))) []))])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)], result := (.list .bytes), + body := (.«match» (.list .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 6 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := (.list .bytes), + body := (.build .cons (.list .bytes) [(.var 1), (.var 0)]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }] } + +def __fits_4 (subject : ByteArray) (start : Nat) (count : Nat) : Bool := + (((Bool.true && (Bool.true && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) with | Option.some piece => Bool.true | Option.none => Bool.true)) + +theorem __rel_4 (subject : ByteArray) (start : Nat) (count : Nat) : _root_.LexLeanPreservation.FunRel __prog 4 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat start), (_root_.LexLeanTarget.TargetSyntax.Value.nat count)] (_root_.LexLeanPreservation.Rel (__fits_4 subject start count) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.sliceOr subject start count))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some piece => Bool.true | Option.none => Bool.true)) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bytes (match __a with | Option.some piece => piece | Option.none => (ByteArray.mk #[]))) (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_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))) (_root_.LexLeanPreservation.prim_slice_bytes subject start count)) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some piece => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_var rfl)) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl _root_.LexLeanPreservation.conv_value)))) + +def __fits_8 (subject : ByteArray) (position : Nat) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && Bool.true) + +theorem __rel_8 (subject : ByteArray) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 8 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_8 subject position) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (LexLeanStd.Text.byteAt subject position))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_index_bytes subject position)) + +def __fits_5 (subject : ByteArray) (delimiter : UInt8) (state : (Prod Nat (Prod Nat (List ByteArray)))) : Bool := + (Bool.true && (let position : Nat := (state).1; (Bool.true && (let start : Nat := ((state).2).1; (Bool.true && (let pieces : (List ByteArray) := ((state).2).2; (((Bool.true && (Bool.true && Bool.true)) && (__fits_8 (subject) (position))) && (match (LexLeanStd.Text.byteAt (subject) (position)) with | Option.some byte => (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) (delimiter) : Bool) then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) | Option.none => (Bool.true && Bool.true))))))))) + +attribute [local irreducible] LexLeanStd.Text.byteAt LexLeanStd.Text.sliceOr in +theorem __rel_5 (subject : ByteArray) (delimiter : UInt8) (state : (Prod Nat (Prod Nat (List ByteArray)))) : _root_.LexLeanPreservation.FunRel __prog 5 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.u8 delimiter), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) state)] (_root_.LexLeanPreservation.Rel (__fits_5 subject delimiter state) ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (LexLeanStd.Text.splitStep subject delimiter state))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (let position : Nat := (state).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_var rfl)) (let start : Nat := ((state).2).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (let pieces : (List ByteArray) := ((state).2).2; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (fun (__a : (Option UInt8)) => (match __a with | Option.some byte => (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) (delimiter) : Bool) then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option UInt8)) => (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (match __a with | Option.some byte => (if (_root_.LexLeanRuntime.equal (byte) (delimiter) : Bool) then (Option.some (((position + (1 : Nat)), ((position + (1 : Nat)), ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat))) :: pieces)))) : (Option (Prod Nat (Prod Nat (List ByteArray))))) else (Option.some (((position + (1 : Nat)), (start, pieces))) : (Option (Prod Nat (Prod Nat (List ByteArray)))))) | Option.none => (Option.none : (Option (Prod Nat (Prod Nat (List ByteArray))))))) (LexLeanStd.Text.byteAt (subject) (position)) (_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_8 (subject) (position))) (fun (__a : (Option UInt8)) _ => match __a with | Option.some byte => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (if __b then (Option.some (((position + (1 : Nat)), ((position + (1 : Nat)), ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat))) :: pieces)))) : (Option (Prod Nat (Prod Nat (List ByteArray))))) else (Option.some (((position + (1 : Nat)), (start, pieces))) : (Option (Prod Nat (Prod Nat (List ByteArray))))))) (_root_.LexLeanRuntime.equal (byte) (delimiter) : Bool) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte delimiter)) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub position start)) _root_.LexLeanPreservation.convL_nil))) (__rel_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)))))))) + +def __fits_2 (delimiter : UInt8) (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : Bool := + ((Bool.true && (Bool.true && (Bool.true && Bool.true))) && (__fits_5 (subject) (delimiter) (state))) + +attribute [local irreducible] LexLeanStd.Text.splitStep in +theorem __rel_2 (delimiter : UInt8) (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : _root_.LexLeanPreservation.FunRel __prog 2 [(_root_.LexLeanTarget.TargetSyntax.Value.u8 delimiter), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) state)] (_root_.LexLeanPreservation.Rel (__fits_2 delimiter subject state) ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) ((LexLeanStd.Text.splitStep (subject) (delimiter) (state))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_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_5 (subject) (delimiter) (state))) + +def __fits_7 (reversed : (List ByteArray)) (piece : ByteArray) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && Bool.true) + +theorem __rel_7 (reversed : (List ByteArray)) (piece : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 7 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) reversed), (_root_.LexLeanTarget.TargetSyntax.Value.bytes piece)] (_root_.LexLeanPreservation.Rel (__fits_7 reversed piece) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) ((piece :: reversed)))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) + +def __fits_3 (pieces : (List ByteArray)) : Bool := + ((Bool.true && ((Bool.true && Bool.true) && (Bool.true && Bool.true))) && (_root_.LexLeanPreservation.foldFits (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __fits_7 __p0 __p1) ((fun (reversed : (List ByteArray)) (piece : ByteArray) => (piece :: reversed))) (([] : List ByteArray)) (pieces))) + +theorem __rel_3 (pieces : (List ByteArray)) : _root_.LexLeanPreservation.FunRel __prog 3 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) pieces)] (_root_.LexLeanPreservation.Rel (__fits_3 pieces) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.reverse pieces))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_nil) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_listFold (ea := _root_.LexLeanTarget.TargetSyntax.Value.bytes) (es := (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)) (_root_.LexLeanPreservation.listEnc _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun _ => rfl) ((fun (reversed : (List ByteArray)) (piece : ByteArray) => (piece :: reversed))) (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __fits_7 __p0 __p1) 7 [] (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __rel_7 __p0 __p1) (p := __prog) (fi := 6) (ta := .bytes) (ts := (.list .bytes)) rfl (([] : List ByteArray)) (pieces))) + +def __fits_0 (subject : ByteArray) (delimiter : UInt8) : Bool := + (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); ((((Bool.true && (Bool.true && Bool.true)) && (Bool.true && (((Bool.true && (((Bool.true && ((Bool.true && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true))) && (_root_.LexLeanPreservation.untilFits (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __fits_2 (delimiter) (subject) __p0) ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.splitStep (subject) (delimiter) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))))) && (let final : (Prod Nat (Prod Nat (List ByteArray))) := ((_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.splitStep (subject) (delimiter) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))) : (Prod (Prod Nat (Prod Nat (List ByteArray))) Bool))).1; (Bool.true && (let start : Nat := ((final).2).1; ((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && (__fits_3 (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: ((final).2).2)))))))))) + +attribute [local irreducible] LexLeanStd.Text.reverse LexLeanStd.Text.sliceOr LexLeanStd.Text.splitStep in +theorem __rel_0 (subject : ByteArray) (delimiter : UInt8) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (let final : (Prod Nat (Prod Nat (List ByteArray))) := ((_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.splitStep (subject) (delimiter) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))) : (Prod (Prod Nat (Prod Nat (List ByteArray))) Bool))).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_nil) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_iterateUntil (es := (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (_root_.LexLeanPreservation.optEnc (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (fun _ => rfl) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) _root_.LexLeanTarget.TargetSyntax.Value.bool) (fun _ => rfl) ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.splitStep (subject) (delimiter) (state)))) (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __fits_2 (delimiter) (subject) __p0) 2 [(_root_.LexLeanTarget.TargetSyntax.Value.u8 delimiter), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __rel_2 (delimiter) (subject) __p0) (_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.splitStep (subject) (delimiter) (state))))) (fun _ => rfl) (fun _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (fun _ _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (p := __prog) (fi := 1) (ts := (.pair .nat (.pair .nat (.list .bytes)))) rfl (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray))))))) (let start : Nat := ((final).2).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub total start)) _root_.LexLeanPreservation.convL_nil))) (__rel_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat)))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) _root_.LexLeanPreservation.convL_nil) (__rel_3 (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: ((final).2).2))))))) + +def denote (subject : ByteArray) (delimiter : UInt8) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject delimiter) (_root_.LexLeanPreservation.Obs.value (((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.splitOn subject delimiter)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..54b0b5727b --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/Compose/RustStd.lex.tex @@ -0,0 +1,486 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.root : @979 := @980 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.flags +@3 := ByteArray +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@29 := @27 @4 @15 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @29 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@37 := @36 @15 +@41 := {A : @10} -> (b : @3) -> @37 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := UInt8 +@51 := LexLeanTarget.TargetSyntax.Value.u8 +@52 := @51 @15 +@55 := LexLeanTarget.TargetSyntax.Ty.fixed LexLeanTarget.TargetSyntax.IntKind.u8 +@56 := @51 @17 +@62 := {p : @8} -> {c : @9} -> {A : @10} -> (x : @50) -> @16 @56 @55 +@64 := LexLeanPreservation.Rust.wt_u8 @0 +@69 := {c : @9} -> {A : @10} -> (x : @50) -> @29 @56 @55 +@70 := @64 @1 +@74 := {A : @10} -> (x : @50) -> @37 @56 @55 +@75 := @70 @2 +@78 := (x : @50) -> @43 @56 @55 +@79 := @75 @15 +@81 := @43 @52 @55 +@82 := LexLeanTarget.TargetSyntax.Value +@83 := List.nil.{0} +@84 := List.cons.{0} +@85 := @83 @82 +@86 := @84 @82 +@88 := @86 @52 @85 +@90 := @86 @6 @88 +@91 := Nat +@94 := Prod.{0, 0} @91 @82 +@95 := 1 +@98 := Prod.mk.{0, 0} @91 @82 +@99 := @98 @95 +@100 := @99 @52 +@101 := 0 +@102 := @98 @101 +@103 := @102 @6 +@104 := @83 @94 +@105 := @84 @94 +@107 := @105 @103 @104 +@109 := @105 @100 @107 +@110 := Bool.true +@111 := LexLeanTarget.TargetSyntax.Function +@112 := LexLeanTarget.TargetSyntax.Program.functions +@113 := @112 @0 +@114 := LexLeanTarget.TargetSyntax.Ty +@115 := @83 @91 +@116 := @83 @114 +@117 := LexLeanTarget.TargetSyntax.Ty.unit +@118 := LexLeanTarget.TargetSyntax.Value.unit +@121 := LexLeanTarget.TargetSyntax.Expr.value @117 @118 +@126 := LexLeanTarget.TargetSyntax.Function.mk @115 @116 @117 @121 +@131 := List.getD.{0} @111 @113 @101 @126 +@135 := fun (__e_n : @91) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@147 := @136 @0 +@153 := {c : @9} -> {A : @10} -> @147 @15 @17 @85 @116 +@154 := @146 @1 +@155 := @147 @1 +@159 := {A : @10} -> @155 @17 @85 @116 +@160 := @154 @2 +@161 := @155 @2 +@162 := @161 @85 +@163 := @162 @116 +@164 := List.{0} +@165 := @164 @82 +@166 := @164 @114 +@167 := #6 +@168 := @11 @167 +@169 := #5 +@170 := @168 @169 +@171 := #4 +@174 := @170 @171 @12 @4 +@175 := #7 +@180 := @136 @175 @167 @169 @4 @15 +@181 := #8 +@184 := @136 @181 @175 @167 +@186 := @86 @169 @12 +@187 := @184 @186 +@188 := @84 @114 +@190 := @188 @171 @4 +@200 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @82} -> {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @174) -> (hs : @180) -> @187 @190 +@202 := LexLeanPreservation.Rust.wtl_cons @0 +@222 := {c : @9} -> + {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> + (h : @27 @169 @171 @12 @4) -> (hs : @147 @167 @169 @4 @15) -> @147 @175 @167 @186 @190 +@223 := @202 @1 +@239 := {A : @10} -> + {v : @82} -> + {t : @114} -> + {vs : @165} -> + {ts : @166} -> (h : @36 @171 @12 @4) -> (hs : @155 @169 @4 @15) -> @155 @167 @186 @190 +@240 := @223 @2 +@242 := @43 @12 @4 +@244 := @161 @4 @15 +@252 := {v : @82} -> + {t : @114} -> {vs : @165} -> {ts : @166} -> (h : @242) -> (hs : @244) -> @161 @186 @190 +@253 := @240 @52 +@254 := @51 @171 +@256 := @43 @254 @4 +@257 := @51 @167 +@258 := @86 @257 +@266 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @256) -> (hs : @244) -> @161 (@258 @12) @190 +@267 := @253 @55 +@268 := @51 @12 +@270 := @43 @268 @55 +@271 := @51 @169 +@272 := @86 @271 +@274 := @161 (@272 @12) +@275 := @188 @55 +@276 := @275 @4 +@281 := {vs : @165} -> {ts : @166} -> (h : @270) -> (hs : @244) -> @274 @276 +@282 := @267 @85 +@283 := @51 @4 +@285 := @43 @283 @55 +@286 := @162 @15 +@288 := @86 @254 @85 +@293 := {ts : @166} -> (h : @285) -> (hs : @286) -> @161 @288 @276 +@294 := @282 @116 +@296 := @86 @268 @85 +@297 := @161 @296 +@298 := @275 @116 +@301 := (h : @81) -> (hs : @163) -> @297 @298 +@302 := @294 @79 +@304 := @86 @283 @85 +@306 := @161 @304 @298 +@307 := (hs : @163) -> @306 +@308 := @302 @160 +@310 := @161 @88 @298 +@311 := @240 @6 +@312 := @5 @169 +@314 := @43 @312 @4 +@315 := @5 @175 +@316 := @86 @315 +@324 := {t : @114} -> + {vs : @165} -> {ts : @166} -> (h : @314) -> (hs : @244) -> @161 (@316 @12) @190 +@325 := @311 @7 +@326 := @5 @171 +@328 := @43 @326 @7 +@329 := @5 @167 +@330 := @86 @329 +@332 := @161 (@330 @12) +@333 := @188 @7 +@334 := @333 @4 +@339 := {vs : @165} -> {ts : @166} -> (h : @328) -> (hs : @244) -> @332 @334 +@340 := @325 @88 +@341 := @5 @12 +@343 := @43 @341 @7 +@344 := @297 @15 +@346 := @86 @312 @288 +@347 := @161 @346 +@351 := {ts : @166} -> (h : @343) -> (hs : @344) -> @347 @334 +@352 := @340 @298 +@354 := @86 @326 @296 +@355 := @161 @354 +@356 := @333 @298 +@359 := (h : @49) -> (hs : @306) -> @355 @356 +@360 := @352 @47 +@362 := @86 @341 @304 +@363 := @161 @362 +@365 := (hs : @310) -> @363 @356 +@366 := @360 @308 +@367 := @161 @90 +@368 := @367 @356 +@369 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.denote +@371 := @369 @4 @15 +@372 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.__fits_0 +@374 := @372 @4 @15 +@377 := LexLeanStd.Text.splitOn @4 @15 +@381 := LexLeanPreservation.encList @3 @5 @377 +@384 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.root @4 @15 +@385 := Bool +@386 := Ne.{1} +@387 := LexLeanPreservation.Obs +@388 := @386 @387 +@389 := LexLeanPreservation.Rel +@392 := @388 (@389 @15 @17) +@393 := LexLeanPreservation.Obs.stuck +@396 := (f : @385) -> (v : @82) -> @392 @393 +@398 := LexLeanPreservation.Rust.rel_ne_stuck @374 +@405 := (v : @82) -> @388 (@389 (@372 @12 @4) @17) @393 +@406 := @398 @381 +@410 := @388 (@389 @374 @381) @393 +@411 := @164 @94 +@412 := LexLeanPreservation.Rust.FunSem +@413 := #9 +@419 := (n : @91) -> @412 @413 @181 @175 @17 @167 +@420 := Eq.{1} +@421 := Option.{0} +@422 := @421 @111 +@423 := @420 @422 +@430 := LexLeanRuntime.index (@164 @111) @111 (LexLeanRuntime.instIndexableList @111) +@434 := @423 (@430 (@112 @413) @167) +@435 := Option.some.{0} +@436 := @435 @111 +@437 := @436 @169 +@438 := @434 @437 +@439 := #10 +@443 := @136 @439 @413 @181 @169 +@444 := LexLeanTarget.TargetSyntax.Function.types +@445 := @444 @167 +@446 := @443 @445 +@447 := @421 @411 +@448 := @420 @447 +@449 := LexLeanTarget.TargetSemantics.bindAll +@450 := LexLeanTarget.TargetSyntax.Function.parameters +@455 := @448 (@449 (@450 @175) @167 @104) +@456 := @435 @411 +@457 := @456 @169 +@458 := @455 @457 +@459 := @421 @385 +@460 := @420 @459 +@461 := LexLeanPreservation.Rust.fnFallible +@462 := #11 +@465 := @460 (@461 @462 @413) +@466 := @435 @385 +@467 := @466 @169 +@468 := @465 @467 +@469 := LexLeanPreservation.RunConv +@470 := #13 +@474 := @469 @470 @439 @181 @169 +@476 := @388 @167 @393 +@477 := Exists.{1} +@478 := LexLeanPreservation.Rust.ROut +@479 := @477 @478 +@480 := And +@481 := LexLeanPreservation.Rust.RealizesFn +@485 := @480 (@481 @413 @181 @17) +@486 := LexLeanPreservation.Rust.RCI +@488 := @486 #15 +@489 := LexLeanPreservation.Rust.fnIdent +@490 := @489 @470 +@497 := (hne : @476) -> @479 (fun (ro : @478) => @485 (@488 @490 @462 @17)) +@512 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @411} -> + {F : @385} -> + {o : @387} -> + (hB : @419) -> + (hfn : @438) -> (hwt : @446) -> (hbind : @458) -> (hF : @468) -> (hA : @474) -> @497 +@514 := LexLeanPreservation.Rust.compose @0 +@515 := @412 @0 +@520 := (n : @91) -> @515 @181 @175 @17 @167 +@521 := @430 @113 +@524 := @423 (@521 @167) @437 +@528 := @147 @413 @181 @169 @445 +@529 := @469 @0 +@532 := @529 @439 @181 @169 +@546 := {c : @9} -> + {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @411} -> + {F : @385} -> + {o : @387} -> + (hB : @520) -> + (hfn : @524) -> (hwt : @528) -> (hbind : @458) -> (hF : @468) -> (hA : @532) -> @497 +@547 := @514 @1 +@548 := @515 @1 +@552 := (n : @91) -> @548 @175 @17 @167 +@555 := @155 @181 @169 @445 +@556 := @461 @1 +@559 := @460 (@556 @413) @467 +@560 := @486 @1 +@570 := (hbind : @458) -> + (hF : @559) -> (hA : @532) -> (hne : @476) -> @479 (fun (ro : @478) => @485 (@560 @490 @462 @17)) +@580 := {A : @10} -> + {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @411} -> {F : @385} -> {o : @387} -> (hB : @552) -> (hfn : @524) -> (hwt : @555) -> @570 +@581 := @547 @2 +@583 := @548 @2 @17 +@585 := (n : @91) -> @583 @167 +@586 := @161 @169 +@587 := @586 @445 +@596 := {f : @91} -> + {fn : @111} -> + {args : @165} -> + {env : @411} -> {F : @385} -> {o : @387} -> (hB : @585) -> (hfn : @524) -> (hwt : @587) -> @570 +@597 := @581 @101 +@599 := (n : @91) -> @583 @101 +@600 := @521 @101 +@601 := @423 @600 +@602 := @601 @437 +@603 := @556 @101 +@604 := @460 @603 +@605 := @604 @467 +@606 := @529 @101 +@608 := @606 @181 @169 +@610 := @560 (@489 @101) +@618 := (hF : @605) -> (hA : @608) -> (hne : @476) -> @479 (fun (ro : @478) => @485 (@610 @462 @17)) +@627 := {fn : @111} -> + {args : @165} -> + {env : @411} -> + {F : @385} -> {o : @387} -> (hB : @599) -> (hfn : @602) -> (hwt : @587) -> (hbind : @458) -> @618 +@628 := @597 @131 +@630 := @601 (@436 @131) +@631 := @444 @131 +@632 := @586 @631 +@634 := @449 (@450 @131) +@646 := {args : @165} -> + {env : @411} -> + {F : @385} -> + {o : @387} -> + (hB : @599) -> (hfn : @630) -> (hwt : @632) -> (hbind : @448 (@634 @167 @104) @457) -> @618 +@647 := @628 @90 +@649 := @316 (@258 @85) +@651 := @161 @649 @631 +@657 := @86 (@5 @181) (@86 (@51 @175) @85) +@661 := @448 (@634 @657 @104) @457 +@667 := @86 (@5 @439) (@86 (@51 @413) @85) +@669 := @606 @667 @169 +@671 := @86 (@5 @470) +@672 := #12 +@691 := {env : @411} -> + {F : @385} -> + {o : @387} -> + (hB : @599) -> + (hfn : @630) -> + (hwt : @651) -> + (hbind : @661) -> + (hF : @605) -> + (hA : @669) -> + (hne : @476) -> @479 (fun (ro : @478) => @485 (@610 (@671 (@86 (@51 @672) @85)) @17)) +@692 := @647 @109 +@694 := @330 (@272 @85) +@696 := @161 @694 @631 +@707 := @448 (@634 @649 @104) (@456 (@105 (@99 @257) (@105 (@102 @315) @104))) +@713 := @86 (@5 @413) (@86 (@51 @181) @85) +@735 := {F : @385} -> + {o : @387} -> + (hB : @599) -> + (hfn : @630) -> + (hwt : @696) -> + (hbind : @707) -> + (hF : @605) -> + (hA : @606 @713 @169) -> + (hne : @476) -> @479 (fun (ro : @478) => @485 (@610 (@86 (@5 @672) (@86 (@51 @462) @85)) @17)) +@736 := @692 @110 +@737 := @347 @631 +@748 := @448 (@634 @694 @104) (@456 (@105 (@99 @271) (@105 (@102 @329) @104))) +@750 := @604 (@466 @110) +@752 := @606 @657 @169 +@753 := @481 @110 +@775 := {o : @387} -> + (hB : @599) -> + (hfn : @630) -> + (hwt : @737) -> + (hbind : @748) -> + (hF : @750) -> + (hA : @752) -> + (hne : @476) -> + @479 (fun (ro : @478) => @480 (@753 @181 @17) (@610 (@86 (@5 @462) (@86 (@51 @439) @85)) @17)) +@776 := @736 @371 +@777 := @355 @631 +@788 := @448 (@634 @346 @104) (@456 (@105 (@99 @254) (@105 (@102 @312) @104))) +@789 := @606 @649 +@791 := @369 @175 @167 +@792 := @789 @791 +@794 := @369 @181 @175 +@813 := (hB : @599) -> + (hfn : @630) -> + (hwt : @777) -> + (hbind : @788) -> + (hF : @750) -> + (hA : @792) -> + (hne : @388 @794 @393) -> + @479 (fun (ro : @478) => @480 (@753 (@369 @439 @413) @17) (@610 @667 @17)) +@814 := @776 @135 +@815 := @363 @631 +@826 := @448 (@634 @354 @104) (@456 (@105 (@99 @268) (@105 (@102 @326) @104))) +@827 := @606 @694 +@829 := @369 @167 @169 +@848 := (hfn : @630) -> + (hwt : @815) -> + (hbind : @826) -> + (hF : @750) -> + (hA : @827 @829) -> + (hne : @388 @791 @393) -> + @479 (fun (ro : @478) => @480 (@753 (@369 @413 @181) @17) (@610 @713 @17)) +@849 := Eq.refl.{1} +@852 := @814 (@849 @422 @600) +@853 := @367 @631 +@864 := @448 (@634 @362 @104) (@456 (@105 (@99 @283) (@105 (@102 @341) @104))) +@865 := @606 @346 +@867 := @369 @169 @171 +@883 := (hwt : @853) -> + (hbind : @864) -> + (hF : @750) -> + (hA : @865 @867) -> + (hne : @388 @829 @393) -> @479 (fun (ro : @478) => @480 (@753 @794 @17) (@610 @657 @17)) +@884 := @852 @366 +@886 := @634 @90 @104 +@889 := @448 @886 (@456 @109) +@890 := @606 @354 +@892 := @369 @171 @12 +@907 := (hbind : @889) -> + (hF : @750) -> + (hA : @890 @892) -> + (hne : @388 @867 @393) -> @479 (fun (ro : @478) => @480 (@753 @791 @17) (@610 @649 @17)) +@910 := @884 (@849 @447 @886) +@911 := @606 @362 +@913 := @369 @12 @4 +@927 := (hF : @750) -> + (hA : @911 @913) -> + (hne : @388 @892 @393) -> @479 (fun (ro : @478) => @480 (@753 @829 @17) (@610 @694 @17)) +@930 := @910 (@849 @459 @603) +@944 := (hA : @606 @90 @371) -> + (hne : @388 @913 @393) -> @479 (fun (ro : @478) => @480 (@753 @867 @17) (@610 @346 @17)) +@945 := @930 @384 +@956 := (hne : @388 @371 @393) -> @479 (fun (ro : @478) => @480 (@753 @892 @17) (@610 @354 @17)) +@957 := @945 @406 +@963 := @480 (@753 @913 @17) (@610 @362 @17) +@965 := @479 (fun (ro : @478) => @963) +@967 := @479 (fun (__e_ro : @478) => @963) +@968 := LexLeanPreservation.Rust.RepresentableL +@969 := @5 @15 +@971 := @86 @56 @85 +@974 := @968 (@86 @969 @971) +@975 := (__e_hrep : @974) -> @967 +@976 := fun (__e_hrep : @974) => @957 +@977 := (delimiter : @50) -> @975 +@978 := fun (delimiter : @50) => @976 +@979 := (subject : @3) -> @977 +@980 := fun (subject : @3) => @978 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/RustStd.lean new file mode 100644 index 0000000000..74a36ae2ed --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/RustStd.lean @@ -0,0 +1,101 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, (.fixed .u8)], result := (.list .bytes), + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 (.pair .nat (.pair .nat (.list .bytes))) (.first (.call 1 [(.closure 2 [(.var 1), (.var 0)]), (.var 2), (.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.value .nat (.nat 0)), (.build .pair (.pair .nat (.list .bytes)) [(.value .nat (.nat 0)), (.build .nil (.list .bytes) [])])])])) (.«let» 4 .nat (.first (.second (.var 3))) (.call 3 [(.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 4), (.prim .natSub [(.var 2), (.var 4)])]), (.second (.second (.var 3)))])])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))], result := (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool), + body := (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1, 2], types := [(.fixed .u8), .bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.call 5 [(.var 1), (.var 0), (.var 2)]) }, + { parameters := [0], types := [(.list .bytes)], result := (.list .bytes), + body := (.call 6 [(.closure 7 []), (.build .nil (.list .bytes) []), (.var 0)]) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [.bytes, (.fixed .u8), (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.«let» 3 .nat (.first (.var 2)) (.«let» 4 .nat (.first (.second (.var 2))) (.«let» 5 (.list .bytes) (.second (.second (.var 2))) (.«match» (.option (.pair .nat (.pair .nat (.list .bytes)))) (.call 8 [(.var 0), (.var 3)]) [(.arm .some [6] (.cond (.prim .equal [(.var 6), (.var 1)]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 4), (.prim .natSub [(.var 3), (.var 4)])]), (.var 5)])])])]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 3), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.var 4), (.var 5)])])]))), (.arm .none [] (.build .none (.option (.pair .nat (.pair .nat (.list .bytes)))) []))])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)], result := (.list .bytes), + body := (.«match» (.list .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 6 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := (.list .bytes), + body := (.build .cons (.list .bytes) [(.var 1), (.var 0)]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.enum (.fn 0) [{ number := 2, fields := [(.fixed .u8), .bytes] }]), + (.apply 0 [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes)))) true [{ function := 2, captures := [.copy, .clone], functionFallible := true }]), + (.enum (.fn 1) [{ number := 7, fields := [] }]), + (.apply 1 [(.list .bytes), .bytes] (.list .bytes) false [{ function := 7, captures := [], functionFallible := false }]), + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := (.fixed .u8) }] (.fallible (.list .bytes)) (.mk [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some (.pair .nat (.pair .nat (.list .bytes)))) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.copy (.generated .binding 1)), (.clone (.generated .binding 0))]), (.copy (.generated .binding 2)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))] (.move (.generated .part 2))))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 3)))] (.move (.generated .part 4)))))] (.move (.generated .part 3)))))] (.succeed (.call (.function 3) [(.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))] false), (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 7))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 8))]) none (.move (.generated .binding 3)))] (.move (.generated .part 8)))))] (.move (.generated .part 7))))])] false)))), + (.function (.generated .function 1) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 0) }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool)) (.mk [(.mk (.bind (.generated .holder 9)) none (.copy (.generated .binding 1)))] (.cond (.isZero (.generated .holder 9)) (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 9))), (.mk (.bind (.generated .holder 11)) none (.block (.mk [(.mk (.bind (.generated .callee 10)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 10) [(.clone (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 11)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))]))))), + (.function (.generated .function 2) [{ pattern := (.bind (.generated .binding 0)), type := (.fixed .u8) }, { pattern := (.bind (.generated .binding 1)), type := .bytes }, { pattern := (.bind (.generated .binding 2)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.option (.pair .nat (.pair .nat (.list .bytes))))) (.mk [] (.call (.function 5) [(.move (.generated .binding 1)), (.copy (.generated .binding 0)), (.move (.generated .binding 2))] false))), + (.function (.generated .function 3) [{ pattern := (.bind (.generated .binding 0)), type := (.list .bytes) }] (.list .bytes) (.mk [] (.call (.function 6) [(.construct (.closure 1 7) []), (.construct (.nil .bytes) []), (.move (.generated .binding 0))] false))), + (.function (.generated .function 4) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .nat }] .bytes (.mk [(.mk (.bind (.generated .holder 15)) none (.block (.mk [(.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 14)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 12)), (.move (.generated .operand 13)), (.move (.generated .operand 14))] false))))] (.matchOn (.move (.generated .holder 15)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]))), + (.function (.generated .function 5) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := (.fixed .u8) }, { pattern := (.bind (.generated .binding 2)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.option (.pair .nat (.pair .nat (.list .bytes))))) (.mk [(.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 16)), .wild]) none (.clone (.generated .binding 2)))] (.move (.generated .part 16))))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 17)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 18))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 18)))))] (.move (.generated .part 17))))), (.mk (.bind (.generated .binding 5)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 19))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.move (.generated .binding 2)))] (.move (.generated .part 20)))))] (.move (.generated .part 19))))), (.mk (.bind (.generated .holder 21)) none (.call (.function 8) [(.clone (.generated .binding 0)), (.copy (.generated .binding 3))] false))] (.matchOn (.move (.generated .holder 21)) [(.mk .none (.mk [] (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) [])))), (.mk (.some (.bind (.generated .binding 6))) (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 6))), (.mk (.bind (.generated .operand 23)) none (.copy (.generated .binding 1)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 25)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] false)))] false), (.move (.generated .binding 5))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 31)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] true))) (.pair (.copy (.generated .binding 4)) (.move (.generated .binding 5))))]))))))]))), + (.function (.generated .function 6) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 1) }, { pattern := (.bind (.generated .binding 1)), type := (.list .bytes) }, { pattern := (.bind (.generated .binding 2)), type := (.list .bytes) }] (.list .bytes) (.mk [(.mk (.bind (.generated .holder 32)) none (.move (.generated .binding 2)))] (.matchOn (.uncons (.generated .holder 32)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 33)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 33) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]))), + (.function (.generated .function 7) [{ pattern := (.bind (.generated .binding 0)), type := (.list .bytes) }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] (.list .bytes) (.mk [] (.construct .cons [(.move (.generated .binding 1)), (.move (.generated .binding 0))]))), + (.function (.generated .function 8) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] (.option (.fixed .u8)) (.mk [(.mk (.bind (.generated .operand 34)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 1)))] (.call (.runtime .indexBytes) [(.move (.generated .operand 34)), (.move (.generated .operand 35))] false)))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [(([(.pair .nat (.pair .nat (.list .bytes)))], (.option (.pair .nat (.pair .nat (.list .bytes))))), true), (([(.list .bytes), .bytes], (.list .bytes)), false)] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some (.pair .nat (.pair .nat (.list .bytes)))) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.copy (.generated .binding 1)), (.clone (.generated .binding 0))]), (.copy (.generated .binding 2)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))] (.move (.generated .part 2))))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 3)))] (.move (.generated .part 4)))))] (.move (.generated .part 3)))))], (.succeed (.call (.function 3) [(.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))] false), (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 7))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 8))]) none (.move (.generated .binding 3)))] (.move (.generated .part 8)))))] (.move (.generated .part 7))))])] false)), [(1, (.fixed .u8), (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.copy (.generated .binding 1)), (.clone (.generated .binding 0))]), (.copy (.generated .binding 2)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))]) (tail := (.move (.generated .part 2))) (Corr.first (ta := (.pair .nat (.pair .nat (.list .bytes)))) (tb := .bool) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [(.fixed .u8), .bytes]) (mask := [false, false]) (af := true) (ff := true) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.value rfl rfl) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.value rfl rfl) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 3)))] (.move (.generated .part 4)))))]) (tail := (.move (.generated .part 3))) (Corr.first (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 3)))]) (tail := (.move (.generated .part 4))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.fOfB (Corr.callOps (ts := [(.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 5)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 6)) none (.copy (.generated .binding 4)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 7))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 8))]) none (.move (.generated .binding 3)))] (.move (.generated .part 8)))))]) (tail := (.move (.generated .part 7))) (Corr.second (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 8))]) none (.move (.generated .binding 3)))]) (tail := (.move (.generated .part 8))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) (Corr.lNil)))) rfl)) (Corr.lNil))) rfl rfl rfl rfl rfl)))))⟩⟩ + +theorem fun1 : FunOK program krate flags 1 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 9)) none (.copy (.generated .binding 1)))], (.cond (.isZero (.generated .holder 9)) (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 9))), (.mk (.bind (.generated .holder 11)) none (.block (.mk [(.mk (.bind (.generated .callee 10)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 10) [(.clone (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 11)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))]))), [(2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))], rfl, rfl, + (Corr.matchNat (sl := (some 3)) (Corr.var rfl rfl) rfl rfl rfl (Corr.kIf (la := []) (ta := (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (lb := [(.mk (.bind (.generated .holder 11)) none (.block (.mk [(.mk (.bind (.generated .callee 10)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 10) [(.clone (.generated .binding 2))] true))))]) (tb := (.matchOn (.move (.generated .holder 11)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))])) (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil)))))) (Corr.matchArms (st := (.option (.pair .nat (.pair .nat (.list .bytes))))) (U := []) (view := false) (idx := [0, 1]) (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 10)) (some (.fn 0)) (.clone (.generated .binding 0)))]) (tail := (.apply (.generated .callee 10) [(.clone (.generated .binding 2))] true)) (Corr.apply (ps := [(.pair .nat (.pair .nat (.list .bytes)))]) (af := true) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true))))) (Corr.mCons (Γ' := [(4, (.pair .nat (.pair .nat (.list .bytes))), (some 4)), (3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callF (ts := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl)) rfl rfl rfl (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil))))))) rfl rfl rfl)))⟩⟩ + +theorem fun2 : FunOK program krate flags 2 := + ⟨_, rfl, .inl ⟨_, _, [], (.call (.function 5) [(.move (.generated .binding 1)), (.copy (.generated .binding 0)), (.move (.generated .binding 2))] false), [(2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .bytes, (some 1)), (0, (.fixed .u8), (some 0))], rfl, rfl, + (Corr.callF (ts := [.bytes, (.fixed .u8), (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl)⟩⟩ + +theorem fun3 : FunOK program krate flags 3 := + ⟨_, rfl, .inl ⟨_, _, [], (.call (.function 6) [(.construct (.closure 1 7) []), (.construct (.nil .bytes) []), (.move (.generated .binding 0))] false), [(0, (.list .bytes), (some 0))], rfl, rfl, + (Corr.callOps (ts := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := []) (mask := []) (af := false) (ff := false) (Corr.opsNil) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)⟩⟩ + +theorem fun4 : FunOK program krate flags 4 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 15)) none (.block (.mk [(.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 14)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 12)), (.move (.generated .operand 13)), (.move (.generated .operand 14))] false))))], (.matchOn (.move (.generated .holder 15)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]), [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 12)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 14)) none (.copy (.generated .binding 2)))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 12)), (.move (.generated .operand 13)), (.move (.generated .operand 14))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bytes (ByteArray.mk #[])))) (Corr.mCons (Γ' := [(3, .bytes, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 3))) (Corr.mNil) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl (Corr.bOfE (Corr.value rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun5 : FunOK program krate flags 5 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 16)), .wild]) none (.clone (.generated .binding 2)))] (.move (.generated .part 16))))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 17)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 18))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 18)))))] (.move (.generated .part 17))))), (.mk (.bind (.generated .binding 5)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 19))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.move (.generated .binding 2)))] (.move (.generated .part 20)))))] (.move (.generated .part 19))))), (.mk (.bind (.generated .holder 21)) none (.call (.function 8) [(.clone (.generated .binding 0)), (.copy (.generated .binding 3))] false))], (.matchOn (.move (.generated .holder 21)) [(.mk .none (.mk [] (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) [])))), (.mk (.some (.bind (.generated .binding 6))) (.mk [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 6))), (.mk (.bind (.generated .operand 23)) none (.copy (.generated .binding 1)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 25)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] false)))] false), (.move (.generated .binding 5))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 31)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] true))) (.pair (.copy (.generated .binding 4)) (.move (.generated .binding 5))))]))))))]), [(2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, (.fixed .u8), (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 16)), .wild]) none (.clone (.generated .binding 2)))]) (tail := (.move (.generated .part 16))) (Corr.first (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 17)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 18))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 18)))))]) (tail := (.move (.generated .part 17))) (Corr.first (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 18))]) none (.clone (.generated .binding 2)))]) (tail := (.move (.generated .part 18))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 19))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.move (.generated .binding 2)))] (.move (.generated .part 20)))))]) (tail := (.move (.generated .part 19))) (Corr.second (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.move (.generated .binding 2)))]) (tail := (.move (.generated .part 20))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.matchArms (st := (.option (.fixed .u8))) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(5, (.list .bytes), (some 5)), (4, .nat, (some 4)), (3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, (.fixed .u8), (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) []))) (Corr.mCons (Γ' := [(6, (.fixed .u8), (some 6)), (5, (.list .bytes), (some 5)), (4, .nat, (some 4)), (3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, (.fixed .u8), (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 6))), (.mk (.bind (.generated .operand 23)) none (.copy (.generated .binding 1)))]) (tail := (.cond (.call (.runtime .equal) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 25)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] false)))] false), (.move (.generated .binding 5))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 31)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] true))) (.pair (.copy (.generated .binding 4)) (.move (.generated .binding 5))))]))))) (Corr.mNil) rfl rfl rfl (Corr.cond (lc := [(.mk (.bind (.generated .operand 22)) none (.copy (.generated .binding 6))), (.mk (.bind (.generated .operand 23)) none (.copy (.generated .binding 1)))]) (ce := (.call (.runtime .equal) [(.move (.generated .operand 22)), (.move (.generated .operand 23))] false)) (lk := []) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 25)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 4)), (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 4)))] (.call (.runtime .natSub) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] false)))] false), (.move (.generated .binding 5))])))]))) (lb := []) (tb := (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 31)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] true))) (.pair (.copy (.generated .binding 4)) (.move (.generated .binding 5))))]))) (Corr.fOfB (Corr.build (ts := [(.pair .nat (.pair .nat (.list .bytes)))]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 25)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 29)) none (.copy (.generated .binding 4)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl)) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))) rfl)) (Corr.fOfB (Corr.build (ts := [(.pair .nat (.pair .nat (.list .bytes)))]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 31)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))) rfl))))) rfl rfl rfl (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl))) rfl rfl rfl))))⟩⟩ + +theorem fun6 : FunOK program krate flags 6 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 32)) none (.move (.generated .binding 2)))], (.matchOn (.uncons (.generated .holder 32)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 33)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 33) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]), [(2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))], rfl, rfl, + (Corr.matchArms (st := (.list .bytes)) (U := []) (view := true) (idx := [0, 1]) (Corr.var rfl rfl) (Corr.mCons (Γ' := [(2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 1))) (Corr.mCons (Γ' := [(4, (.list .bytes), (some 4)), (3, .bytes, (some 3)), (2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 33)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 33) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callOps (ts := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 33)) (some (.fn 1)) (.move (.generated .binding 0)))]) (tail := (.apply (.generated .callee 33) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false)) (Corr.apply (ps := [(.list .bytes), .bytes]) (af := false) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun7 : FunOK program krate flags 7 := + ⟨_, rfl, .inl ⟨_, _, [], (.construct .cons [(.move (.generated .binding 1)), (.move (.generated .binding 0))]), [(1, .bytes, (some 1)), (0, (.list .bytes), (some 0))], rfl, rfl, + (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl)⟩⟩ + +theorem fun8 : FunOK program krate flags 8 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 34)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 35)) none (.copy (.generated .binding 1)))], (.call (.runtime .indexBytes) [(.move (.generated .operand 34)), (.move (.generated .operand 35))] false), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.prim (ts := [.bytes, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | 1 => exact fun1 + | 2 => exact fun2 + | 3 => exact fun3 + | 4 => exact fun4 + | 5 => exact fun5 + | 6 => exact fun6 + | 7 => exact fun7 + | 8 => exact fun8 + | _ + 9 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4.lean new file mode 100644 index 0000000000..c7c89b7d8e --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4.lean @@ -0,0 +1,105 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0], types := [.bytes], result := (.list .bytes), + body := (.«let» 1 .nat (.prim .length [(.var 0)]) (.«let» 2 (.pair .nat (.pair .nat (.list .bytes))) (.first (.call 1 [(.closure 2 [(.var 0)]), (.var 1), (.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.value .nat (.nat 0)), (.build .pair (.pair .nat (.list .bytes)) [(.value .nat (.nat 0)), (.build .nil (.list .bytes) [])])])])) (.«let» 3 .nat (.first (.second (.var 2))) (.«let» 4 (.list .bytes) (.second (.second (.var 2))) (.cond (.prim .natLt [(.var 3), (.var 1)]) (.call 3 [(.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 3), (.prim .natSub [(.var 1), (.var 3)])]), (.var 4)])]) (.call 3 [(.var 4)])))))) }, + { parameters := [0, 1, 2], types := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))], result := (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool), + body := (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1], types := [.bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.call 5 [(.var 0), (.var 1)]) }, + { parameters := [0], types := [(.list .bytes)], result := (.list .bytes), + body := (.call 6 [(.closure 7 []), (.build .nil (.list .bytes) []), (.var 0)]) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1], types := [.bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.«let» 2 .nat (.first (.var 1)) (.«let» 3 .nat (.first (.second (.var 1))) (.«let» 4 (.list .bytes) (.second (.second (.var 1))) (.«match» (.option (.pair .nat (.pair .nat (.list .bytes)))) (.call 8 [(.var 0), (.var 2)]) [(.arm .some [5] (.cond (.prim .equal [(.var 5), (.value (.fixed .u8) (.u8 10))]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .cons (.list .bytes) [(.call 9 [(.call 4 [(.var 0), (.var 3), (.prim .natSub [(.var 2), (.var 3)])])]), (.var 4)])])])]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.var 3), (.var 4)])])]))), (.arm .none [] (.build .none (.option (.pair .nat (.pair .nat (.list .bytes)))) []))])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)], result := (.list .bytes), + body := (.«match» (.list .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 6 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := (.list .bytes), + body := (.build .cons (.list .bytes) [(.var 1), (.var 0)]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }, + { parameters := [0], types := [.bytes], result := .bytes, + body := (.cond (.call 10 [(.var 0), (.value .bytes (.bytes (ByteArray.mk #[13])))]) (.call 4 [(.var 0), (.value .nat (.nat 0)), (.prim .natSub [(.prim .length [(.var 0)]), (.value .nat (.nat 1))])]) (.var 0)) }, + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.cond (.prim .natLe [(.var 3), (.var 2)]) (.«match» .bool (.prim .slice [(.var 0), (.prim .natSub [(.var 2), (.var 3)]), (.var 3)]) [(.arm .some [4] (.prim .equal [(.var 4), (.var 1)])), (.arm .none [] (.build .false .bool []))]) (.build .false .bool [])))) }] } + +def __fits_4 (subject : ByteArray) (start : Nat) (count : Nat) : Bool := + (((Bool.true && (Bool.true && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) with | Option.some piece => Bool.true | Option.none => Bool.true)) + +theorem __rel_4 (subject : ByteArray) (start : Nat) (count : Nat) : _root_.LexLeanPreservation.FunRel __prog 4 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat start), (_root_.LexLeanTarget.TargetSyntax.Value.nat count)] (_root_.LexLeanPreservation.Rel (__fits_4 subject start count) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.sliceOr subject start count))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some piece => Bool.true | Option.none => Bool.true)) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bytes (match __a with | Option.some piece => piece | Option.none => (ByteArray.mk #[]))) (_root_.LexLeanRuntime.slice (subject) (start) (count) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_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))) (_root_.LexLeanPreservation.prim_slice_bytes subject start count)) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some piece => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_var rfl)) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl _root_.LexLeanPreservation.conv_value)))) + +def __fits_8 (subject : ByteArray) (position : Nat) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && Bool.true) + +theorem __rel_8 (subject : ByteArray) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 8 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_8 subject position) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (LexLeanStd.Text.byteAt subject position))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_index_bytes subject position)) + +def __fits_10 (subject : ByteArray) (suffix : ByteArray) : Bool := + (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (suffix) : Nat) 18446744073709551616)) && (let size : Nat := (_root_.LexLeanRuntime.length (suffix) : Nat); (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.ble size total) then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) else (Bool.true && Bool.true))))))) + +theorem __rel_10 (subject : ByteArray) (suffix : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 10 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.bytes suffix)] (_root_.LexLeanPreservation.Rel (__fits_10 subject suffix) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.endsWith subject suffix))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (let size : Nat := (_root_.LexLeanRuntime.length (suffix) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes suffix)) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then (((Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) else (Bool.true && Bool.true))) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bool (if __b then (match (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) with | Option.some tail => (_root_.LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => Bool.false) else Bool.false)) (Nat.ble size total) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLe size total)) (fun _ => (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some tail => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bool (match __a with | Option.some tail => (_root_.LexLeanRuntime.equal (tail) (suffix) : Bool) | Option.none => Bool.false)) (_root_.LexLeanRuntime.slice (subject) ((_root_.LexLeanRuntime.subtract (total) (size) : Nat)) (size) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub total size)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.prim_slice_bytes subject (_root_.LexLeanRuntime.subtract (total) (size) : Nat) size)) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some tail => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_bytes tail suffix))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false)))))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false))))) + +def __fits_9 (line : ByteArray) : Bool := + (((Bool.true && (Bool.true && Bool.true)) && (__fits_10 (line) ((ByteArray.mk #[13])))) && (if (LexLeanStd.Text.endsWith (line) ((ByteArray.mk #[13]))) then ((Bool.true && (Bool.true && (((((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (line) : Nat) 18446744073709551616)) && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (line) ((0 : Nat)) ((_root_.LexLeanRuntime.subtract ((_root_.LexLeanRuntime.length (line) : Nat)) ((1 : Nat)) : Nat)))) else Bool.true)) + +attribute [local irreducible] LexLeanStd.Text.endsWith LexLeanStd.Text.sliceOr in +theorem __rel_9 (line : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 9 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes line)] (_root_.LexLeanPreservation.Rel (__fits_9 line) (_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.chomp line))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((Bool.true && (Bool.true && (((((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (line) : Nat) 18446744073709551616)) && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (line) ((0 : Nat)) ((_root_.LexLeanRuntime.subtract ((_root_.LexLeanRuntime.length (line) : Nat)) ((1 : Nat)) : Nat)))) else Bool.true)) (fun (__b : Bool) => _root_.LexLeanTarget.TargetSyntax.Value.bytes (if __b then (LexLeanStd.Text.sliceOr (line) ((0 : Nat)) ((_root_.LexLeanRuntime.subtract ((_root_.LexLeanRuntime.length (line) : Nat)) ((1 : Nat)) : Nat))) else line)) (LexLeanStd.Text.endsWith (line) ((ByteArray.mk #[13]))) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (__rel_10 (line) ((ByteArray.mk #[13])))) (fun _ => (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes line)) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub (_root_.LexLeanRuntime.length (line) : Nat) (1 : Nat))) _root_.LexLeanPreservation.convL_nil))) (__rel_4 (line) ((0 : Nat)) ((_root_.LexLeanRuntime.subtract ((_root_.LexLeanRuntime.length (line) : Nat)) ((1 : Nat)) : Nat))))) (fun _ => (_root_.LexLeanPreservation.conv_var rfl))) + +def __fits_5 (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : Bool := + (Bool.true && (let position : Nat := (state).1; (Bool.true && (let start : Nat := ((state).2).1; (Bool.true && (let pieces : (List ByteArray) := ((state).2).2; (((Bool.true && (Bool.true && Bool.true)) && (__fits_8 (subject) (position))) && (match (LexLeanStd.Text.byteAt (subject) (position)) with | Option.some byte => (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && Bool.true) && (__fits_9 ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) | Option.none => (Bool.true && Bool.true))))))))) + +attribute [local irreducible] LexLeanStd.Text.byteAt LexLeanStd.Text.chomp LexLeanStd.Text.sliceOr in +theorem __rel_5 (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : _root_.LexLeanPreservation.FunRel __prog 5 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) state)] (_root_.LexLeanPreservation.Rel (__fits_5 subject state) ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (LexLeanStd.Text.lineStep subject state))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (let position : Nat := (state).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_var rfl)) (let start : Nat := ((state).2).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (let pieces : (List ByteArray) := ((state).2).2; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.u8) (fun (__a : (Option UInt8)) => (match __a with | Option.some byte => (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && Bool.true) && (__fits_9 ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option UInt8)) => (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (match __a with | Option.some byte => (if (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) then (Option.some (((position + (1 : Nat)), ((position + (1 : Nat)), ((LexLeanStd.Text.chomp ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat))))) :: pieces)))) : (Option (Prod Nat (Prod Nat (List ByteArray))))) else (Option.some (((position + (1 : Nat)), (start, pieces))) : (Option (Prod Nat (Prod Nat (List ByteArray)))))) | Option.none => (Option.none : (Option (Prod Nat (Prod Nat (List ByteArray))))))) (LexLeanStd.Text.byteAt (subject) (position)) (_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_8 (subject) (position))) (fun (__a : (Option UInt8)) _ => match __a with | Option.some byte => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) && Bool.true) && (__fits_9 ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true) else ((((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (if __b then (Option.some (((position + (1 : Nat)), ((position + (1 : Nat)), ((LexLeanStd.Text.chomp ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat))))) :: pieces)))) : (Option (Prod Nat (Prod Nat (List ByteArray))))) else (Option.some (((position + (1 : Nat)), (start, pieces))) : (Option (Prod Nat (Prod Nat (List ByteArray))))))) (_root_.LexLeanRuntime.equal (byte) ((10 : UInt8)) : Bool) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_u8 byte (10 : UInt8))) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_call (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub position start)) _root_.LexLeanPreservation.convL_nil))) (__rel_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))) _root_.LexLeanPreservation.convL_nil) (__rel_9 ((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (position) (start) : Nat)))))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)))))))) + +def __fits_2 (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && (__fits_5 (subject) (state))) + +attribute [local irreducible] LexLeanStd.Text.lineStep in +theorem __rel_2 (subject : ByteArray) (state : (Prod Nat (Prod Nat (List ByteArray)))) : _root_.LexLeanPreservation.FunRel __prog 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), ((_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) state)] (_root_.LexLeanPreservation.Rel (__fits_2 subject state) ((_root_.LexLeanPreservation.encOption (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) ((LexLeanStd.Text.lineStep (subject) (state))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_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_5 (subject) (state))) + +def __fits_7 (reversed : (List ByteArray)) (piece : ByteArray) : Bool := + ((Bool.true && (Bool.true && Bool.true)) && Bool.true) + +theorem __rel_7 (reversed : (List ByteArray)) (piece : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 7 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) reversed), (_root_.LexLeanTarget.TargetSyntax.Value.bytes piece)] (_root_.LexLeanPreservation.Rel (__fits_7 reversed piece) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) ((piece :: reversed)))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) + +def __fits_3 (pieces : (List ByteArray)) : Bool := + ((Bool.true && ((Bool.true && Bool.true) && (Bool.true && Bool.true))) && (_root_.LexLeanPreservation.foldFits (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __fits_7 __p0 __p1) ((fun (reversed : (List ByteArray)) (piece : ByteArray) => (piece :: reversed))) (([] : List ByteArray)) (pieces))) + +theorem __rel_3 (pieces : (List ByteArray)) : _root_.LexLeanPreservation.FunRel __prog 3 [((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) pieces)] (_root_.LexLeanPreservation.Rel (__fits_3 pieces) ((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.reverse pieces))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_nil) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_listFold (ea := _root_.LexLeanTarget.TargetSyntax.Value.bytes) (es := (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)) (_root_.LexLeanPreservation.listEnc _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun _ => rfl) ((fun (reversed : (List ByteArray)) (piece : ByteArray) => (piece :: reversed))) (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __fits_7 __p0 __p1) 7 [] (fun (__p0 : (List ByteArray)) (__p1 : ByteArray) => __rel_7 __p0 __p1) (p := __prog) (fi := 6) (ta := .bytes) (ts := (.list .bytes)) rfl (([] : List ByteArray)) (pieces))) + +def __fits_0 (subject : ByteArray) : Bool := + (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); ((((Bool.true && Bool.true) && (Bool.true && (((Bool.true && (((Bool.true && ((Bool.true && Bool.true) && Bool.true)) && Bool.true) && Bool.true)) && Bool.true) && Bool.true))) && (_root_.LexLeanPreservation.untilFits (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __fits_2 (subject) __p0) ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.lineStep (subject) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))))) && (let final : (Prod Nat (Prod Nat (List ByteArray))) := ((_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.lineStep (subject) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))) : (Prod (Prod Nat (Prod Nat (List ByteArray))) Bool))).1; (Bool.true && (let start : Nat := ((final).2).1; (Bool.true && (let pieces : (List ByteArray) := ((final).2).2; (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.blt start total) then ((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && (__fits_3 (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: pieces)))) else ((Bool.true && Bool.true) && (__fits_3 (pieces))))))))))))) + +attribute [local irreducible] LexLeanStd.Text.lineStep LexLeanStd.Text.reverse LexLeanStd.Text.sliceOr in +theorem __rel_0 (subject : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (let final : (Prod Nat (Prod Nat (List ByteArray))) := ((_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.lineStep (subject) (state)))) (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray)))) : (Prod (Prod Nat (Prod Nat (List ByteArray))) Bool))).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_nil) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_pair) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_iterateUntil (es := (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (_root_.LexLeanPreservation.optEnc (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes)))) (fun _ => rfl) (_root_.LexLeanPreservation.encPair (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes))) _root_.LexLeanTarget.TargetSyntax.Value.bool) (fun _ => rfl) ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.lineStep (subject) (state)))) (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __fits_2 (subject) __p0) 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject)] (fun (__p0 : (Prod Nat (Prod Nat (List ByteArray)))) => __rel_2 (subject) __p0) (_root_.LexLeanCollections.iterateUntil ((fun (state : (Prod Nat (Prod Nat (List ByteArray)))) => (LexLeanStd.Text.lineStep (subject) (state))))) (fun _ => rfl) (fun _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (fun _ _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (p := __prog) (fi := 1) (ts := (.pair .nat (.pair .nat (.list .bytes)))) rfl (total) (((0 : Nat), ((0 : Nat), ([] : List ByteArray))))))) (let start : Nat := ((final).2).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (let pieces : (List ByteArray) := ((final).2).2; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_second (_root_.LexLeanPreservation.conv_var rfl))) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((((Bool.true && (Bool.true && (((Bool.true && (Bool.true && Bool.true)) && Bool.true) && Bool.true))) && (__fits_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat)))) && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && (__fits_3 (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: pieces)))) else ((Bool.true && Bool.true) && (__fits_3 (pieces))))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (if __b then (LexLeanStd.Text.reverse (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: pieces))) else (LexLeanStd.Text.reverse (pieces)))) (Nat.blt start total) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLt start total)) (fun _ => (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natSub total start)) _root_.LexLeanPreservation.convL_nil))) (__rel_4 (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat)))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) _root_.LexLeanPreservation.construct_cons) _root_.LexLeanPreservation.convL_nil) (__rel_3 (((LexLeanStd.Text.sliceOr (subject) (start) ((_root_.LexLeanRuntime.subtract (total) (start) : Nat))) :: pieces))))) (fun _ => (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (__rel_3 (pieces))))))))) + +def denote (subject : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject) (_root_.LexLeanPreservation.Obs.value (((_root_.LexLeanPreservation.encList _root_.LexLeanTarget.TargetSyntax.Value.bytes) (LexLeanStd.Text.lines subject)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..be7db2e587 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/Compose/RustStd.lex.tex @@ -0,0 +1,419 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.root : @829 := @830 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.flags +@3 := ByteArray +@4 := #1 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@13 := @11 @12 +@14 := #2 +@16 := @13 @14 @4 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @27 @14 @4 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (b : @3) -> @36 @4 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := LexLeanTarget.TargetSyntax.Value +@51 := List.nil.{0} +@52 := List.cons.{0} +@53 := @51 @50 +@54 := @52 @50 +@56 := @54 @6 @53 +@57 := Nat +@60 := Prod.{0, 0} @57 @50 +@61 := 0 +@65 := Prod.mk.{0, 0} @57 @50 @61 +@66 := @65 @6 +@67 := @51 @60 +@68 := @52 @60 +@70 := @68 @66 @67 +@71 := Bool.true +@72 := LexLeanTarget.TargetSyntax.Function +@73 := LexLeanTarget.TargetSyntax.Program.functions +@74 := @73 @0 +@75 := LexLeanTarget.TargetSyntax.Ty +@76 := @51 @57 +@77 := @51 @75 +@78 := LexLeanTarget.TargetSyntax.Ty.unit +@79 := LexLeanTarget.TargetSyntax.Value.unit +@82 := LexLeanTarget.TargetSyntax.Expr.value @78 @79 +@87 := LexLeanTarget.TargetSyntax.Function.mk @76 @77 @78 @82 +@92 := List.getD.{0} @72 @74 @61 @87 +@96 := fun (__e_n : @57) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@108 := @97 @0 +@114 := {c : @9} -> {A : @10} -> @108 @4 @17 @53 @77 +@115 := @107 @1 +@116 := @108 @1 +@120 := {A : @10} -> @116 @17 @53 @77 +@121 := @115 @2 +@122 := @116 @2 +@123 := @122 @53 +@124 := @123 @77 +@125 := List.{0} +@126 := @125 @50 +@127 := @125 @75 +@128 := #6 +@129 := @11 @128 +@130 := #5 +@131 := @129 @130 +@132 := #4 +@135 := @131 @132 @12 @14 +@136 := #7 +@141 := @97 @136 @128 @130 @14 @4 +@142 := #8 +@145 := @97 @142 @136 @128 +@147 := @54 @130 @12 +@148 := @145 @147 +@149 := @52 @75 +@151 := @149 @132 @14 +@161 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @50} -> {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @135) -> (hs : @141) -> @148 @151 +@163 := LexLeanPreservation.Rust.wtl_cons @0 +@183 := {c : @9} -> + {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> + (h : @27 @130 @132 @12 @14) -> (hs : @108 @128 @130 @14 @4) -> @108 @136 @128 @147 @151 +@184 := @163 @1 +@200 := {A : @10} -> + {v : @50} -> + {t : @75} -> + {vs : @126} -> + {ts : @127} -> (h : @36 @132 @12 @14) -> (hs : @116 @130 @14 @4) -> @116 @128 @147 @151 +@201 := @184 @2 +@203 := @43 @12 @14 +@205 := @122 @14 @4 +@213 := {v : @50} -> + {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @203) -> (hs : @205) -> @122 @147 @151 +@214 := @201 @6 +@215 := @5 @132 +@217 := @43 @215 @14 +@218 := @5 @128 +@219 := @54 @218 +@227 := {t : @75} -> {vs : @126} -> {ts : @127} -> (h : @217) -> (hs : @205) -> @122 (@219 @12) @151 +@228 := @214 @7 +@229 := @5 @12 +@231 := @43 @229 @7 +@232 := @5 @130 +@233 := @54 @232 +@235 := @122 (@233 @12) +@236 := @149 @7 +@237 := @236 @14 +@242 := {vs : @126} -> {ts : @127} -> (h : @231) -> (hs : @205) -> @235 @237 +@243 := @228 @53 +@244 := @5 @14 +@246 := @43 @244 @7 +@247 := @123 @4 +@249 := @54 @215 @53 +@250 := @122 @249 +@254 := {ts : @127} -> (h : @246) -> (hs : @247) -> @250 @237 +@255 := @243 @77 +@257 := @54 @229 @53 +@258 := @122 @257 +@259 := @236 @77 +@262 := (h : @49) -> (hs : @124) -> @258 @259 +@263 := @255 @47 +@265 := @54 @244 @53 +@266 := @122 @265 +@268 := (hs : @124) -> @266 @259 +@269 := @263 @121 +@270 := @122 @56 +@271 := @270 @259 +@272 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.denote +@273 := @272 @4 +@274 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.__fits_0 +@275 := @274 @4 +@277 := LexLeanStd.Text.lines @4 +@281 := LexLeanPreservation.encList @3 @5 @277 +@283 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.root @4 +@284 := Bool +@285 := Ne.{1} +@286 := LexLeanPreservation.Obs +@287 := @285 @286 +@288 := LexLeanPreservation.Rel +@291 := @287 (@288 @4 @17) +@292 := LexLeanPreservation.Obs.stuck +@295 := (f : @284) -> (v : @50) -> @291 @292 +@297 := LexLeanPreservation.Rust.rel_ne_stuck @275 +@303 := (v : @50) -> @287 (@288 (@274 @14) @17) @292 +@304 := @297 @281 +@308 := @287 (@288 @275 @281) @292 +@309 := @125 @60 +@310 := LexLeanPreservation.Rust.FunSem +@311 := #9 +@317 := (n : @57) -> @310 @311 @142 @136 @17 @128 +@318 := Eq.{1} +@319 := Option.{0} +@320 := @319 @72 +@321 := @318 @320 +@328 := LexLeanRuntime.index (@125 @72) @72 (LexLeanRuntime.instIndexableList @72) +@332 := @321 (@328 (@73 @311) @128) +@333 := Option.some.{0} +@334 := @333 @72 +@335 := @334 @130 +@336 := @332 @335 +@337 := #10 +@341 := @97 @337 @311 @142 @130 +@342 := LexLeanTarget.TargetSyntax.Function.types +@343 := @342 @128 +@344 := @341 @343 +@345 := @319 @309 +@346 := @318 @345 +@347 := LexLeanTarget.TargetSemantics.bindAll +@348 := LexLeanTarget.TargetSyntax.Function.parameters +@353 := @346 (@347 (@348 @136) @128 @67) +@354 := @333 @309 +@355 := @354 @130 +@356 := @353 @355 +@357 := @319 @284 +@358 := @318 @357 +@359 := LexLeanPreservation.Rust.fnFallible +@360 := #11 +@363 := @358 (@359 @360 @311) +@364 := @333 @284 +@365 := @364 @130 +@366 := @363 @365 +@367 := LexLeanPreservation.RunConv +@368 := #13 +@372 := @367 @368 @337 @142 @130 +@374 := @287 @128 @292 +@375 := Exists.{1} +@376 := LexLeanPreservation.Rust.ROut +@377 := @375 @376 +@378 := And +@379 := LexLeanPreservation.Rust.RealizesFn +@383 := @378 (@379 @311 @142 @17) +@384 := LexLeanPreservation.Rust.RCI +@386 := @384 #15 +@387 := LexLeanPreservation.Rust.fnIdent +@388 := @387 @368 +@395 := (hne : @374) -> @377 (fun (ro : @376) => @383 (@386 @388 @360 @17)) +@410 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @309} -> + {F : @284} -> + {o : @286} -> + (hB : @317) -> + (hfn : @336) -> (hwt : @344) -> (hbind : @356) -> (hF : @366) -> (hA : @372) -> @395 +@412 := LexLeanPreservation.Rust.compose @0 +@413 := @310 @0 +@418 := (n : @57) -> @413 @142 @136 @17 @128 +@419 := @328 @74 +@422 := @321 (@419 @128) @335 +@426 := @108 @311 @142 @130 @343 +@427 := @367 @0 +@430 := @427 @337 @142 @130 +@444 := {c : @9} -> + {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @309} -> + {F : @284} -> + {o : @286} -> + (hB : @418) -> + (hfn : @422) -> (hwt : @426) -> (hbind : @356) -> (hF : @366) -> (hA : @430) -> @395 +@445 := @412 @1 +@446 := @413 @1 +@450 := (n : @57) -> @446 @136 @17 @128 +@453 := @116 @142 @130 @343 +@454 := @359 @1 +@457 := @358 (@454 @311) @365 +@458 := @384 @1 +@468 := (hbind : @356) -> + (hF : @457) -> (hA : @430) -> (hne : @374) -> @377 (fun (ro : @376) => @383 (@458 @388 @360 @17)) +@478 := {A : @10} -> + {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @309} -> {F : @284} -> {o : @286} -> (hB : @450) -> (hfn : @422) -> (hwt : @453) -> @468 +@479 := @445 @2 +@481 := @446 @2 @17 +@483 := (n : @57) -> @481 @128 +@484 := @122 @130 +@485 := @484 @343 +@494 := {f : @57} -> + {fn : @72} -> + {args : @126} -> + {env : @309} -> {F : @284} -> {o : @286} -> (hB : @483) -> (hfn : @422) -> (hwt : @485) -> @468 +@495 := @479 @61 +@497 := (n : @57) -> @481 @61 +@498 := @419 @61 +@499 := @321 @498 +@500 := @499 @335 +@501 := @454 @61 +@502 := @358 @501 +@503 := @502 @365 +@504 := @427 @61 +@506 := @504 @142 @130 +@508 := @458 (@387 @61) +@516 := (hF : @503) -> (hA : @506) -> (hne : @374) -> @377 (fun (ro : @376) => @383 (@508 @360 @17)) +@525 := {fn : @72} -> + {args : @126} -> + {env : @309} -> + {F : @284} -> {o : @286} -> (hB : @497) -> (hfn : @500) -> (hwt : @485) -> (hbind : @356) -> @516 +@526 := @495 @92 +@528 := @499 (@334 @92) +@529 := @342 @92 +@530 := @484 @529 +@532 := @347 (@348 @92) +@544 := {args : @126} -> + {env : @309} -> + {F : @284} -> + {o : @286} -> + (hB : @497) -> (hfn : @528) -> (hwt : @530) -> (hbind : @346 (@532 @128 @67) @355) -> @516 +@545 := @526 @56 +@546 := @219 @53 +@548 := @122 @546 @529 +@551 := @54 (@5 @136) @53 +@555 := @346 (@532 @551 @67) @355 +@558 := @54 (@5 @311) @53 +@579 := {env : @309} -> + {F : @284} -> + {o : @286} -> + (hB : @497) -> + (hfn : @528) -> + (hwt : @548) -> + (hbind : @555) -> + (hF : @503) -> + (hA : @504 @558 @130) -> + (hne : @374) -> @377 (fun (ro : @376) => @383 (@508 (@54 (@5 #12) @53) @17)) +@580 := @545 @70 +@581 := @233 @53 +@583 := @122 @581 @529 +@591 := @346 (@532 @546 @67) (@354 (@68 (@65 @218) @67)) +@594 := @54 (@5 @142) @53 +@613 := {F : @284} -> + {o : @286} -> + (hB : @497) -> + (hfn : @528) -> + (hwt : @583) -> + (hbind : @591) -> + (hF : @503) -> + (hA : @504 @594 @130) -> + (hne : @374) -> @377 (fun (ro : @376) => @383 (@508 (@54 (@5 @360) @53) @17)) +@614 := @580 @71 +@615 := @250 @529 +@623 := @346 (@532 @581 @67) (@354 (@68 (@65 @232) @67)) +@625 := @502 (@364 @71) +@627 := @504 @551 @130 +@628 := @379 @71 +@647 := {o : @286} -> + (hB : @497) -> + (hfn : @528) -> + (hwt : @615) -> + (hbind : @623) -> + (hF : @625) -> + (hA : @627) -> + (hne : @374) -> @377 (fun (ro : @376) => @378 (@628 @142 @17) (@508 (@54 (@5 @337) @53) @17)) +@648 := @614 @273 +@649 := @258 @529 +@657 := @346 (@532 @249 @67) (@354 (@68 (@65 @215) @67)) +@658 := @504 @546 +@659 := @272 @128 +@660 := @658 @659 +@661 := @272 @136 +@679 := (hB : @497) -> + (hfn : @528) -> + (hwt : @649) -> + (hbind : @657) -> + (hF : @625) -> + (hA : @660) -> + (hne : @287 @661 @292) -> @377 (fun (ro : @376) => @378 (@628 (@272 @311) @17) (@508 @558 @17)) +@680 := @648 @96 +@681 := @266 @529 +@689 := @346 (@532 @257 @67) (@354 (@68 (@65 @229) @67)) +@690 := @504 @581 +@691 := @272 @130 +@709 := (hfn : @528) -> + (hwt : @681) -> + (hbind : @689) -> + (hF : @625) -> + (hA : @690 @691) -> + (hne : @287 @659 @292) -> @377 (fun (ro : @376) => @378 (@628 (@272 @142) @17) (@508 @594 @17)) +@710 := Eq.refl.{1} +@713 := @680 (@710 @320 @498) +@714 := @270 @529 +@722 := @346 (@532 @265 @67) (@354 (@68 (@65 @244) @67)) +@723 := @504 @249 +@724 := @272 @132 +@740 := (hwt : @714) -> + (hbind : @722) -> + (hF : @625) -> + (hA : @723 @724) -> + (hne : @287 @691 @292) -> @377 (fun (ro : @376) => @378 (@628 @661 @17) (@508 @551 @17)) +@741 := @713 @269 +@743 := @532 @56 @67 +@746 := @346 @743 (@354 @70) +@747 := @504 @257 +@748 := @272 @12 +@763 := (hbind : @746) -> + (hF : @625) -> + (hA : @747 @748) -> + (hne : @287 @724 @292) -> @377 (fun (ro : @376) => @378 (@628 @659 @17) (@508 @546 @17)) +@766 := @741 (@710 @345 @743) +@767 := @504 @265 +@768 := @272 @14 +@782 := (hF : @625) -> + (hA : @767 @768) -> + (hne : @287 @748 @292) -> @377 (fun (ro : @376) => @378 (@628 @691 @17) (@508 @581 @17)) +@785 := @766 (@710 @357 @501) +@799 := (hA : @504 @56 @273) -> + (hne : @287 @768 @292) -> @377 (fun (ro : @376) => @378 (@628 @724 @17) (@508 @249 @17)) +@800 := @785 @283 +@811 := (hne : @287 @273 @292) -> @377 (fun (ro : @376) => @378 (@628 @748 @17) (@508 @257 @17)) +@812 := @800 @304 +@818 := @378 (@628 @768 @17) (@508 @265 @17) +@820 := @377 (fun (ro : @376) => @818) +@822 := @377 (fun (__e_ro : @376) => @818) +@826 := LexLeanPreservation.Rust.RepresentableL (@54 @18 @53) +@827 := (__e_hrep : @826) -> @822 +@828 := fun (__e_hrep : @826) => @812 +@829 := (subject : @3) -> @827 +@830 := fun (subject : @3) => @828 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/RustStd.lean new file mode 100644 index 0000000000..73d50319f8 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/RustStd.lean @@ -0,0 +1,117 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0], types := [.bytes], result := (.list .bytes), + body := (.«let» 1 .nat (.prim .length [(.var 0)]) (.«let» 2 (.pair .nat (.pair .nat (.list .bytes))) (.first (.call 1 [(.closure 2 [(.var 0)]), (.var 1), (.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.value .nat (.nat 0)), (.build .pair (.pair .nat (.list .bytes)) [(.value .nat (.nat 0)), (.build .nil (.list .bytes) [])])])])) (.«let» 3 .nat (.first (.second (.var 2))) (.«let» 4 (.list .bytes) (.second (.second (.var 2))) (.cond (.prim .natLt [(.var 3), (.var 1)]) (.call 3 [(.build .cons (.list .bytes) [(.call 4 [(.var 0), (.var 3), (.prim .natSub [(.var 1), (.var 3)])]), (.var 4)])]) (.call 3 [(.var 4)])))))) }, + { parameters := [0, 1, 2], types := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))], result := (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool), + body := (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1], types := [.bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.call 5 [(.var 0), (.var 1)]) }, + { parameters := [0], types := [(.list .bytes)], result := (.list .bytes), + body := (.call 6 [(.closure 7 []), (.build .nil (.list .bytes) []), (.var 0)]) }, + { parameters := [0, 1, 2], types := [.bytes, .nat, .nat], result := .bytes, + body := (.«match» .bytes (.prim .slice [(.var 0), (.var 1), (.var 2)]) [(.arm .some [3] (.var 3)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1], types := [.bytes, (.pair .nat (.pair .nat (.list .bytes)))], result := (.option (.pair .nat (.pair .nat (.list .bytes)))), + body := (.«let» 2 .nat (.first (.var 1)) (.«let» 3 .nat (.first (.second (.var 1))) (.«let» 4 (.list .bytes) (.second (.second (.var 1))) (.«match» (.option (.pair .nat (.pair .nat (.list .bytes)))) (.call 8 [(.var 0), (.var 2)]) [(.arm .some [5] (.cond (.prim .equal [(.var 5), (.value (.fixed .u8) (.u8 10))]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .cons (.list .bytes) [(.call 9 [(.call 4 [(.var 0), (.var 3), (.prim .natSub [(.var 2), (.var 3)])])]), (.var 4)])])])]) (.build .some (.option (.pair .nat (.pair .nat (.list .bytes)))) [(.build .pair (.pair .nat (.pair .nat (.list .bytes))) [(.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.build .pair (.pair .nat (.list .bytes)) [(.var 3), (.var 4)])])]))), (.arm .none [] (.build .none (.option (.pair .nat (.pair .nat (.list .bytes)))) []))])))) }, + { parameters := [0, 1, 2], types := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)], result := (.list .bytes), + body := (.«match» (.list .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 6 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := (.list .bytes), + body := (.build .cons (.list .bytes) [(.var 1), (.var 0)]) }, + { parameters := [0, 1], types := [.bytes, .nat], result := (.option (.fixed .u8)), + body := (.prim .index [(.var 0), (.var 1)]) }, + { parameters := [0], types := [.bytes], result := .bytes, + body := (.cond (.call 10 [(.var 0), (.value .bytes (.bytes (ByteArray.mk #[13])))]) (.call 4 [(.var 0), (.value .nat (.nat 0)), (.prim .natSub [(.prim .length [(.var 0)]), (.value .nat (.nat 1))])]) (.var 0)) }, + { parameters := [0, 1], types := [.bytes, .bytes], result := .bool, + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.cond (.prim .natLe [(.var 3), (.var 2)]) (.«match» .bool (.prim .slice [(.var 0), (.prim .natSub [(.var 2), (.var 3)]), (.var 3)]) [(.arm .some [4] (.prim .equal [(.var 4), (.var 1)])), (.arm .none [] (.build .false .bool []))]) (.build .false .bool [])))) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.enum (.fn 0) [{ number := 2, fields := [.bytes] }]), + (.apply 0 [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes)))) true [{ function := 2, captures := [.clone], functionFallible := true }]), + (.enum (.fn 1) [{ number := 7, fields := [] }]), + (.apply 1 [(.list .bytes), .bytes] (.list .bytes) false [{ function := 7, captures := [], functionFallible := false }]), + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }] (.fallible (.list .bytes)) (.mk [(.mk (.bind (.generated .binding 1)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 2)) (some (.pair .nat (.pair .nat (.list .bytes)))) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 0))]), (.copy (.generated .binding 1)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))] (.move (.generated .part 2))))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 4)))))] (.move (.generated .part 3))))), (.mk (.bind (.generated .binding 4)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 5))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 6))]) none (.move (.generated .binding 2)))] (.move (.generated .part 6)))))] (.move (.generated .part 5))))), (.mk (.bind (.generated .operand 7)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1)))] (.cond (.call (.runtime .natLt) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false) (.mk [] (.succeed (.call (.function 3) [(.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] false)))] false), (.move (.generated .binding 4))])] false))) (.mk [] (.succeed (.call (.function 3) [(.move (.generated .binding 4))] false)))))), + (.function (.generated .function 1) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 0) }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.pair (.pair .nat (.pair .nat (.list .bytes))) .bool)) (.mk [(.mk (.bind (.generated .holder 11)) none (.copy (.generated .binding 1)))] (.cond (.isZero (.generated .holder 11)) (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 11))), (.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.clone (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))]))))), + (.function (.generated .function 2) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.option (.pair .nat (.pair .nat (.list .bytes))))) (.mk [] (.call (.function 5) [(.move (.generated .binding 0)), (.move (.generated .binding 1))] false))), + (.function (.generated .function 3) [{ pattern := (.bind (.generated .binding 0)), type := (.list .bytes) }] (.list .bytes) (.mk [] (.call (.function 6) [(.construct (.closure 1 7) []), (.construct (.nil .bytes) []), (.move (.generated .binding 0))] false))), + (.function (.generated .function 4) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .nat }] .bytes (.mk [(.mk (.bind (.generated .holder 17)) none (.block (.mk [(.mk (.bind (.generated .operand 14)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 14)), (.move (.generated .operand 15)), (.move (.generated .operand 16))] false))))] (.matchOn (.move (.generated .holder 17)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]))), + (.function (.generated .function 5) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := (.pair .nat (.pair .nat (.list .bytes))) }] (.fallible (.option (.pair .nat (.pair .nat (.list .bytes))))) (.mk [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 18)), .wild]) none (.clone (.generated .binding 1)))] (.move (.generated .part 18))))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 19)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.clone (.generated .binding 1)))] (.move (.generated .part 20)))))] (.move (.generated .part 19))))), (.mk (.bind (.generated .binding 4)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 21))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 22))]) none (.move (.generated .binding 1)))] (.move (.generated .part 22)))))] (.move (.generated .part 21))))), (.mk (.bind (.generated .holder 23)) none (.call (.function 8) [(.clone (.generated .binding 0)), (.copy (.generated .binding 2))] false))] (.matchOn (.move (.generated .holder 23)) [(.mk .none (.mk [] (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) [])))), (.mk (.some (.bind (.generated .binding 5))) (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 5))), (.mk (.bind (.generated .operand 25)) none (.lit (.fixed .u8 10)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 29)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] true))) (.construct .cons [(.call (.function 9) [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] false)))] false)] false), (.move (.generated .binding 4))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 32)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 33)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 32)), (.move (.generated .operand 33))] true))) (.pair (.copy (.generated .binding 3)) (.move (.generated .binding 4))))]))))))]))), + (.function (.generated .function 6) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 1) }, { pattern := (.bind (.generated .binding 1)), type := (.list .bytes) }, { pattern := (.bind (.generated .binding 2)), type := (.list .bytes) }] (.list .bytes) (.mk [(.mk (.bind (.generated .holder 34)) none (.move (.generated .binding 2)))] (.matchOn (.uncons (.generated .holder 34)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 35)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 35) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]))), + (.function (.generated .function 7) [{ pattern := (.bind (.generated .binding 0)), type := (.list .bytes) }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] (.list .bytes) (.mk [] (.construct .cons [(.move (.generated .binding 1)), (.move (.generated .binding 0))]))), + (.function (.generated .function 8) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }] (.option (.fixed .u8)) (.mk [(.mk (.bind (.generated .operand 36)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 37)) none (.copy (.generated .binding 1)))] (.call (.runtime .indexBytes) [(.move (.generated .operand 36)), (.move (.generated .operand 37))] false))), + (.function (.generated .function 9) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }] .bytes (.mk [] (.cond (.call (.function 10) [(.clone (.generated .binding 0)), (.lit (.bytes (ByteArray.mk #[13])))] false) (.mk [] (.call (.function 4) [(.clone (.generated .binding 0)), (.lit (.nat 0)), (.block (.mk [(.mk (.bind (.generated .operand 39)) none (.block (.mk [(.mk (.bind (.generated .operand 38)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 38))] false)))), (.mk (.bind (.generated .operand 40)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 39)), (.move (.generated .operand 40))] false)))] false)) (.mk [] (.move (.generated .binding 0)))))), + (.function (.generated .function 10) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] .bool (.mk [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 41)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 41))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 42)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 42))] false)))), (.mk (.bind (.generated .operand 43)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 44)) none (.copy (.generated .binding 2)))] (.cond (.call (.runtime .natLe) [(.move (.generated .operand 43)), (.move (.generated .operand 44))] false) (.mk [(.mk (.bind (.generated .holder 50)) none (.block (.mk [(.mk (.bind (.generated .operand 47)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 48)) none (.block (.mk [(.mk (.bind (.generated .operand 45)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 46)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 45)), (.move (.generated .operand 46))] false)))), (.mk (.bind (.generated .operand 49)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 47)), (.move (.generated .operand 48)), (.move (.generated .operand 49))] false))))] (.matchOn (.move (.generated .holder 50)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 51)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 52)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 51)), (.move (.generated .operand 52))] false)))])) (.mk [] (.lit (.bool false))))))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [(([(.pair .nat (.pair .nat (.list .bytes)))], (.option (.pair .nat (.pair .nat (.list .bytes))))), true), (([(.list .bytes), .bytes], (.list .bytes)), false)] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 1)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 2)) (some (.pair .nat (.pair .nat (.list .bytes)))) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 0))]), (.copy (.generated .binding 1)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))] (.move (.generated .part 2))))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 4)))))] (.move (.generated .part 3))))), (.mk (.bind (.generated .binding 4)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 5))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 6))]) none (.move (.generated .binding 2)))] (.move (.generated .part 6)))))] (.move (.generated .part 5))))), (.mk (.bind (.generated .operand 7)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1)))], (.cond (.call (.runtime .natLt) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false) (.mk [] (.succeed (.call (.function 3) [(.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] false)))] false), (.move (.generated .binding 4))])] false))) (.mk [] (.succeed (.call (.function 3) [(.move (.generated .binding 4))] false)))), [(0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 2)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 0))]), (.copy (.generated .binding 1)), (.pair (.lit (.nat 0)) (.pair (.lit (.nat 0)) (.construct (.nil .bytes) [])))] true))]) (tail := (.move (.generated .part 2))) (Corr.first (ta := (.pair .nat (.pair .nat (.list .bytes)))) (tb := .bool) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [.bytes]) (mask := [false]) (af := true) (ff := true) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.value rfl rfl) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.value rfl rfl) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 2)))] (.move (.generated .part 4)))))]) (tail := (.move (.generated .part 3))) (Corr.first (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 4))]) none (.clone (.generated .binding 2)))]) (tail := (.move (.generated .part 4))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 5))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 6))]) none (.move (.generated .binding 2)))] (.move (.generated .part 6)))))]) (tail := (.move (.generated .part 5))) (Corr.second (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 6))]) none (.move (.generated .binding 2)))]) (tail := (.move (.generated .part 6))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.cond (lc := [(.mk (.bind (.generated .operand 7)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 8)) none (.copy (.generated .binding 1)))]) (ce := (.call (.runtime .natLt) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.call (.function 3) [(.construct .cons [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] false)))] false), (.move (.generated .binding 4))])] false))) (lb := []) (tb := (.succeed (.call (.function 3) [(.move (.generated .binding 4))] false))) (Corr.fOfB (Corr.callOps (ts := [(.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl)) (Corr.lNil))) rfl rfl rfl rfl rfl)) (Corr.fOfB (Corr.callOps (ts := [(.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl))))))))⟩⟩ + +theorem fun1 : FunOK program krate flags 1 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 11)) none (.copy (.generated .binding 1)))], (.cond (.isZero (.generated .holder 11)) (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 11))), (.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.clone (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))]))), [(2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))], rfl, rfl, + (Corr.matchNat (sl := (some 3)) (Corr.var rfl rfl) rfl rfl rfl (Corr.kIf (la := []) (ta := (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool false))))) (lb := [(.mk (.bind (.generated .holder 13)) none (.block (.mk [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 12) [(.clone (.generated .binding 2))] true))))]) (tb := (.matchOn (.move (.generated .holder 13)) [(.mk .none (.mk [] (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)))])) (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil)))))) (Corr.matchArms (st := (.option (.pair .nat (.pair .nat (.list .bytes))))) (U := []) (view := false) (idx := [0, 1]) (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 12)) (some (.fn 0)) (.clone (.generated .binding 0)))]) (tail := (.apply (.generated .callee 12) [(.clone (.generated .binding 2))] true)) (Corr.apply (ps := [(.pair .nat (.pair .nat (.list .bytes)))]) (af := true) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.succeed (.pair (.move (.generated .binding 2)) (.lit (.bool true))))) (Corr.mCons (Γ' := [(4, (.pair .nat (.pair .nat (.list .bytes))), (some 4)), (3, .nat, (some 3)), (2, (.pair .nat (.pair .nat (.list .bytes))), (some 2)), (1, .nat, (some 1)), (0, (.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.move (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callF (ts := [(.fn [(.pair .nat (.pair .nat (.list .bytes)))] (.option (.pair .nat (.pair .nat (.list .bytes))))), .nat, (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl)) rfl rfl rfl (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil))))))) rfl rfl rfl)))⟩⟩ + +theorem fun2 : FunOK program krate flags 2 := + ⟨_, rfl, .inl ⟨_, _, [], (.call (.function 5) [(.move (.generated .binding 0)), (.move (.generated .binding 1))] false), [(1, (.pair .nat (.pair .nat (.list .bytes))), (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.callF (ts := [.bytes, (.pair .nat (.pair .nat (.list .bytes)))]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl)⟩⟩ + +theorem fun3 : FunOK program krate flags 3 := + ⟨_, rfl, .inl ⟨_, _, [], (.call (.function 6) [(.construct (.closure 1 7) []), (.construct (.nil .bytes) []), (.move (.generated .binding 0))] false), [(0, (.list .bytes), (some 0))], rfl, rfl, + (Corr.callOps (ts := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := []) (mask := []) (af := false) (ff := false) (Corr.opsNil) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)⟩⟩ + +theorem fun4 : FunOK program krate flags 4 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 17)) none (.block (.mk [(.mk (.bind (.generated .operand 14)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 2)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 14)), (.move (.generated .operand 15)), (.move (.generated .operand 16))] false))))], (.matchOn (.move (.generated .holder 17)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.move (.generated .binding 3))))]), [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 14)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 15)) none (.copy (.generated .binding 1))), (.mk (.bind (.generated .operand 16)) none (.copy (.generated .binding 2)))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 14)), (.move (.generated .operand 15)), (.move (.generated .operand 16))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bytes (ByteArray.mk #[])))) (Corr.mCons (Γ' := [(3, .bytes, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 3))) (Corr.mNil) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl (Corr.bOfE (Corr.value rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun5 : FunOK program krate flags 5 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 18)), .wild]) none (.clone (.generated .binding 1)))] (.move (.generated .part 18))))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 19)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.clone (.generated .binding 1)))] (.move (.generated .part 20)))))] (.move (.generated .part 19))))), (.mk (.bind (.generated .binding 4)) (some (.list .bytes)) (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 21))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 22))]) none (.move (.generated .binding 1)))] (.move (.generated .part 22)))))] (.move (.generated .part 21))))), (.mk (.bind (.generated .holder 23)) none (.call (.function 8) [(.clone (.generated .binding 0)), (.copy (.generated .binding 2))] false))], (.matchOn (.move (.generated .holder 23)) [(.mk .none (.mk [] (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) [])))), (.mk (.some (.bind (.generated .binding 5))) (.mk [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 5))), (.mk (.bind (.generated .operand 25)) none (.lit (.fixed .u8 10)))] (.cond (.call (.runtime .equal) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 29)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] true))) (.construct .cons [(.call (.function 9) [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] false)))] false)] false), (.move (.generated .binding 4))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 32)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 33)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 32)), (.move (.generated .operand 33))] true))) (.pair (.copy (.generated .binding 3)) (.move (.generated .binding 4))))]))))))]), [(1, (.pair .nat (.pair .nat (.list .bytes))), (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 18)), .wild]) none (.clone (.generated .binding 1)))]) (tail := (.move (.generated .part 18))) (Corr.first (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 19)), .wild]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.clone (.generated .binding 1)))] (.move (.generated .part 20)))))]) (tail := (.move (.generated .part 19))) (Corr.first (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 20))]) none (.clone (.generated .binding 1)))]) (tail := (.move (.generated .part 20))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 21))]) none (.block (.mk [(.mk (.tuple [.wild, (.bind (.generated .part 22))]) none (.move (.generated .binding 1)))] (.move (.generated .part 22)))))]) (tail := (.move (.generated .part 21))) (Corr.second (ta := .nat) (tb := (.list .bytes)) (Corr.eOfB (lets := [(.mk (.tuple [.wild, (.bind (.generated .part 22))]) none (.move (.generated .binding 1)))]) (tail := (.move (.generated .part 22))) (Corr.second (ta := .nat) (tb := (.pair .nat (.list .bytes))) (Corr.var rfl rfl) rfl)) rfl)) rfl (Corr.matchArms (st := (.option (.fixed .u8))) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(4, (.list .bytes), (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, (.pair .nat (.pair .nat (.list .bytes))), (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.succeed (.construct (.none (.pair .nat (.pair .nat (.list .bytes)))) []))) (Corr.mCons (Γ' := [(5, (.fixed .u8), (some 5)), (4, (.list .bytes), (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, (.pair .nat (.pair .nat (.list .bytes))), (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 5))), (.mk (.bind (.generated .operand 25)) none (.lit (.fixed .u8 10)))]) (tail := (.cond (.call (.runtime .equal) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] false) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 29)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] true))) (.construct .cons [(.call (.function 9) [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] false)))] false)] false), (.move (.generated .binding 4))])))]))) (.mk [] (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 32)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 33)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 32)), (.move (.generated .operand 33))] true))) (.pair (.copy (.generated .binding 3)) (.move (.generated .binding 4))))]))))) (Corr.mNil) rfl rfl rfl (Corr.cond (lc := [(.mk (.bind (.generated .operand 24)) none (.copy (.generated .binding 5))), (.mk (.bind (.generated .operand 25)) none (.lit (.fixed .u8 10)))]) (ce := (.call (.runtime .equal) [(.move (.generated .operand 24)), (.move (.generated .operand 25))] false)) (lk := []) (Corr.prim (ts := [(.fixed .u8), (.fixed .u8)]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true))) (.pair (.block (.mk [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 29)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] true))) (.construct .cons [(.call (.function 9) [(.call (.function 4) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.block (.mk [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] false)))] false)] false), (.move (.generated .binding 4))])))]))) (lb := []) (tb := (.succeed (.construct .some [(.pair (.block (.mk [(.mk (.bind (.generated .operand 32)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 33)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 32)), (.move (.generated .operand 33))] true))) (.pair (.copy (.generated .binding 3)) (.move (.generated .binding 4))))]))) (Corr.fOfB (Corr.build (ts := [(.pair .nat (.pair .nat (.list .bytes)))]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 26)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 27)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 26)), (.move (.generated .operand 27))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 28)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 29)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 28)), (.move (.generated .operand 29))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.callOps (ts := [.bytes]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 30)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 31)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 30)), (.move (.generated .operand 31))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl)) (Corr.lNil))) rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl)) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))) rfl)) (Corr.fOfB (Corr.build (ts := [(.pair .nat (.pair .nat (.list .bytes)))]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 32)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 33)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 32)), (.move (.generated .operand 33))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) (Corr.lNil)))) (Corr.lNil))) rfl))))) rfl rfl rfl (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl))) rfl rfl rfl))))⟩⟩ + +theorem fun6 : FunOK program krate flags 6 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 34)) none (.move (.generated .binding 2)))], (.matchOn (.uncons (.generated .holder 34)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 35)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 35) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]), [(2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))], rfl, rfl, + (Corr.matchArms (st := (.list .bytes)) (U := []) (view := true) (idx := [0, 1]) (Corr.var rfl rfl) (Corr.mCons (Γ' := [(2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 1))) (Corr.mCons (Γ' := [(4, (.list .bytes), (some 4)), (3, .bytes, (some 3)), (2, (.list .bytes), (some 2)), (1, (.list .bytes), (some 1)), (0, (.fn [(.list .bytes), .bytes] (.list .bytes)), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 6) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 35)) (some (.fn 1)) (.move (.generated .binding 0)))] (.apply (.generated .callee 35) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callOps (ts := [(.fn [(.list .bytes), .bytes] (.list .bytes)), (.list .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 35)) (some (.fn 1)) (.move (.generated .binding 0)))]) (tail := (.apply (.generated .callee 35) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false)) (Corr.apply (ps := [(.list .bytes), .bytes]) (af := false) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun7 : FunOK program krate flags 7 := + ⟨_, rfl, .inl ⟨_, _, [], (.construct .cons [(.move (.generated .binding 1)), (.move (.generated .binding 0))]), [(1, .bytes, (some 1)), (0, (.list .bytes), (some 0))], rfl, rfl, + (Corr.build (ts := [.bytes, (.list .bytes)]) (mask := [false, false]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl)⟩⟩ + +theorem fun8 : FunOK program krate flags 8 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .operand 36)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 37)) none (.copy (.generated .binding 1)))], (.call (.runtime .indexBytes) [(.move (.generated .operand 36)), (.move (.generated .operand 37))] false), [(1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.prim (ts := [.bytes, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)⟩⟩ + +theorem fun9 : FunOK program krate flags 9 := + ⟨_, rfl, .inl ⟨_, _, [], (.cond (.call (.function 10) [(.clone (.generated .binding 0)), (.lit (.bytes (ByteArray.mk #[13])))] false) (.mk [] (.call (.function 4) [(.clone (.generated .binding 0)), (.lit (.nat 0)), (.block (.mk [(.mk (.bind (.generated .operand 39)) none (.block (.mk [(.mk (.bind (.generated .operand 38)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 38))] false)))), (.mk (.bind (.generated .operand 40)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 39)), (.move (.generated .operand 40))] false)))] false)) (.mk [] (.move (.generated .binding 0)))), [(0, .bytes, (some 0))], rfl, rfl, + (Corr.cond (lc := []) (ce := (.call (.function 10) [(.clone (.generated .binding 0)), (.lit (.bytes (ByteArray.mk #[13])))] false)) (lk := []) (Corr.callOps (ts := [.bytes, .bytes]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.value rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.call (.function 4) [(.clone (.generated .binding 0)), (.lit (.nat 0)), (.block (.mk [(.mk (.bind (.generated .operand 39)) none (.block (.mk [(.mk (.bind (.generated .operand 38)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 38))] false)))), (.mk (.bind (.generated .operand 40)) none (.lit (.nat 1)))] (.call (.runtime .natSub) [(.move (.generated .operand 39)), (.move (.generated .operand 40))] false)))] false)) (lb := []) (tb := (.move (.generated .binding 0))) (Corr.callOps (ts := [.bytes, .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.value rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 39)) none (.block (.mk [(.mk (.bind (.generated .operand 38)) none (.move (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 38))] false)))), (.mk (.bind (.generated .operand 40)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 39)), (.move (.generated .operand 40))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 38)) none (.move (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 38))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))))) rfl rfl rfl rfl rfl) (Corr.bOfE (Corr.var rfl rfl))))⟩⟩ + +theorem fun10 : FunOK program krate flags 10 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 41)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 41))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 42)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 42))] false)))), (.mk (.bind (.generated .operand 43)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 44)) none (.copy (.generated .binding 2)))], (.cond (.call (.runtime .natLe) [(.move (.generated .operand 43)), (.move (.generated .operand 44))] false) (.mk [(.mk (.bind (.generated .holder 50)) none (.block (.mk [(.mk (.bind (.generated .operand 47)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 48)) none (.block (.mk [(.mk (.bind (.generated .operand 45)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 46)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 45)), (.move (.generated .operand 46))] false)))), (.mk (.bind (.generated .operand 49)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 47)), (.move (.generated .operand 48)), (.move (.generated .operand 49))] false))))] (.matchOn (.move (.generated .holder 50)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 51)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 52)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 51)), (.move (.generated .operand 52))] false)))])) (.mk [] (.lit (.bool false)))), [(1, .bytes, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 41)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 41))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 42)) none (.clone (.generated .binding 1)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 42))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.cond (lc := [(.mk (.bind (.generated .operand 43)) none (.copy (.generated .binding 3))), (.mk (.bind (.generated .operand 44)) none (.copy (.generated .binding 2)))]) (ce := (.call (.runtime .natLe) [(.move (.generated .operand 43)), (.move (.generated .operand 44))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := [(.mk (.bind (.generated .holder 50)) none (.block (.mk [(.mk (.bind (.generated .operand 47)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 48)) none (.block (.mk [(.mk (.bind (.generated .operand 45)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 46)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 45)), (.move (.generated .operand 46))] false)))), (.mk (.bind (.generated .operand 49)) none (.copy (.generated .binding 3)))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 47)), (.move (.generated .operand 48)), (.move (.generated .operand 49))] false))))]) (ta := (.matchOn (.move (.generated .holder 50)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 4))) (.mk [(.mk (.bind (.generated .operand 51)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 52)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 51)), (.move (.generated .operand 52))] false)))])) (lb := []) (tb := (.lit (.bool false))) (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 47)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 48)) none (.block (.mk [(.mk (.bind (.generated .operand 45)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 46)) none (.copy (.generated .binding 3)))] (.call (.runtime .natSub) [(.move (.generated .operand 45)), (.move (.generated .operand 46))] false)))), (.mk (.bind (.generated .operand 49)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 47)), (.move (.generated .operand 48)), (.move (.generated .operand 49))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 45)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 46)) none (.copy (.generated .binding 3)))]) (tail := (.call (.runtime .natSub) [(.move (.generated .operand 45)), (.move (.generated .operand 46))] false)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bool false))) (Corr.mCons (Γ' := [(4, .bytes, (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 51)) none (.move (.generated .binding 4))), (.mk (.bind (.generated .operand 52)) none (.move (.generated .binding 1)))]) (tail := (.call (.runtime .equal) [(.move (.generated .operand 51)), (.move (.generated .operand 52))] false)) (Corr.mNil) rfl rfl rfl (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.buildConst rfl))) rfl rfl rfl) (Corr.bOfE (Corr.buildConst rfl))))))⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | 1 => exact fun1 + | 2 => exact fun2 + | 3 => exact fun3 + | 4 => exact fun4 + | 5 => exact fun5 + | 6 => exact fun6 + | 7 => exact fun7 + | 8 => exact fun8 + | 9 => exact fun9 + | 10 => exact fun10 + | _ + 11 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5.lean new file mode 100644 index 0000000000..167f0eafe6 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5.lean @@ -0,0 +1,43 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := .bytes, + body := (.«match» .bytes (.call 1 [(.closure 2 [(.var 1)]), (.build .none (.option .bytes) []), (.var 0)]) [(.arm .some [2] (.var 2)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [(.fn [(.option .bytes), .bytes] (.option .bytes)), (.option .bytes), (.list .bytes)], result := (.option .bytes), + body := (.«match» (.option .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 1 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1, 2], types := [.bytes, (.option .bytes), .bytes], result := (.option .bytes), + body := (.«match» (.option .bytes) (.var 1) [(.arm .none [] (.build .some (.option .bytes) [(.var 2)])), (.arm .some [3] (.build .some (.option .bytes) [(.prim .append [(.prim .append [(.var 3), (.var 0)]), (.var 2)])]))]) }] } + +def __fits_2 (separator : ByteArray) (joined : (Option ByteArray)) (piece : ByteArray) : Bool := + (Bool.true && (match joined with | Option.none => ((Bool.true && Bool.true) && Bool.true) | Option.some sofar => ((((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) + +theorem __rel_2 (separator : ByteArray) (joined : (Option ByteArray)) (piece : ByteArray) : _root_.LexLeanPreservation.FunRel __prog 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes separator), ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) joined), (_root_.LexLeanTarget.TargetSyntax.Value.bytes piece)] (_root_.LexLeanPreservation.Rel (__fits_2 separator joined piece) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) ((match joined with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray)))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.none => ((Bool.true && Bool.true) && Bool.true) | Option.some sofar => ((((((Bool.true && (Bool.true && Bool.true)) && Bool.true) && (Bool.true && Bool.true)) && Bool.true) && Bool.true) && Bool.true))) (fun (__a : (Option ByteArray)) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (match __a with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray)))) joined (_root_.LexLeanPreservation.conv_var rfl) (fun (__a : (Option ByteArray)) _ => match __a with | Option.none => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) | Option.some sofar => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_append_bytes sofar separator)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_append_bytes (_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray) piece)) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some))))) + +def __fits_0 (pieces : (List ByteArray)) (separator : ByteArray) : Bool := + ((((Bool.true && Bool.true) && ((Bool.true && Bool.true) && (Bool.true && Bool.true))) && (_root_.LexLeanPreservation.foldFits (fun (__p0 : (Option ByteArray)) (__p1 : ByteArray) => __fits_2 (separator) __p0 __p1) ((fun (joined : (Option ByteArray)) (piece : ByteArray) => (match joined with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray))))) ((Option.none : (Option ByteArray))) (pieces))) && (match (_root_.LexLeanCollections.listFold ((fun (joined : (Option ByteArray)) (piece : ByteArray) => (match joined with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray))))) ((Option.none : (Option ByteArray))) (pieces) : (Option ByteArray)) with | Option.some joined => Bool.true | Option.none => Bool.true)) + +theorem __rel_0 (pieces : (List ByteArray)) (separator : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some joined => Bool.true | Option.none => Bool.true)) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bytes (match __a with | Option.some joined => joined | Option.none => (ByteArray.mk #[]))) (_root_.LexLeanCollections.listFold ((fun (joined : (Option ByteArray)) (piece : ByteArray) => (match joined with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray))))) ((Option.none : (Option ByteArray))) (pieces) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_listFold (ea := _root_.LexLeanTarget.TargetSyntax.Value.bytes) (es := (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes)) (_root_.LexLeanPreservation.listEnc _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun _ => rfl) ((fun (joined : (Option ByteArray)) (piece : ByteArray) => (match joined with | Option.none => (Option.some (piece) : (Option ByteArray)) | Option.some sofar => (Option.some ((_root_.LexLeanRuntime.append ((_root_.LexLeanRuntime.append (sofar) (separator) : ByteArray)) (piece) : ByteArray)) : (Option ByteArray))))) (fun (__p0 : (Option ByteArray)) (__p1 : ByteArray) => __fits_2 (separator) __p0 __p1) 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes separator)] (fun (__p0 : (Option ByteArray)) (__p1 : ByteArray) => __rel_2 (separator) __p0 __p1) (p := __prog) (fi := 1) (ta := .bytes) (ts := (.option .bytes)) rfl ((Option.none : (Option ByteArray))) (pieces))) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some joined => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_var rfl)) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl _root_.LexLeanPreservation.conv_value)))) + +def denote (pieces : (List ByteArray)) (separator : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 pieces separator) (_root_.LexLeanPreservation.Obs.value ((_root_.LexLeanTarget.TargetSyntax.Value.bytes (LexLeanStd.Text.joinWith pieces separator)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..b7446696a6 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/Compose/RustStd.lex.tex @@ -0,0 +1,513 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.root : @1046 := @1047 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.flags +@3 := ByteArray +@4 := List.{0} +@5 := @4 @3 +@6 := #2 +@7 := LexLeanTarget.TargetSyntax.Value.bytes +@8 := LexLeanPreservation.encList +@9 := @8 @3 +@10 := @9 @7 +@11 := @10 @6 +@12 := LexLeanTarget.TargetSyntax.Ty.bytes +@13 := LexLeanTarget.TargetSyntax.Ty.list +@14 := @13 @12 +@15 := #0 +@16 := LexLeanTarget.TargetSyntax.Program +@17 := LexLeanPreservation.Rust.RCrate +@18 := LexLeanPreservation.Rust.Flags +@19 := LexLeanPreservation.Rust.WT +@20 := #3 +@22 := @19 @20 @6 +@23 := #1 +@24 := @22 @23 +@25 := @7 @15 +@31 := {p : @16} -> {c : @17} -> {A : @18} -> (b : @3) -> @24 @25 @12 +@33 := LexLeanPreservation.Rust.wt_bytes @0 +@34 := @19 @0 +@41 := {c : @17} -> {A : @18} -> (b : @3) -> @34 @6 @23 @25 @12 +@42 := @33 @1 +@43 := @34 @1 +@48 := {A : @18} -> (b : @3) -> @43 @23 @25 @12 +@49 := @42 @2 +@50 := @43 @2 +@51 := @50 @25 +@52 := @51 @12 +@53 := (b : @3) -> @52 +@55 := fun (__x : @3) => @49 @15 +@56 := Sort 1 +@57 := LexLeanTarget.TargetSyntax.Value +@58 := (a._@._internal._hyg.#0 : @15) -> @57 +@59 := LexLeanTarget.TargetSyntax.Ty +@60 := #6 +@61 := @19 @60 +@62 := #5 +@63 := @61 @62 +@64 := #4 +@65 := @63 @64 +@66 := @6 @15 +@69 := (x : @6) -> @65 @66 @23 +@70 := @4 @20 +@71 := #7 +@74 := @19 @71 @60 @62 +@77 := @8 @64 @20 @15 +@78 := @74 @77 +@79 := @13 @6 +@88 := {p : @16} -> + {c : @17} -> + {A : @18} -> {α : @56} -> {e : @58} -> {t : @59} -> (h : @69) -> (xs : @70) -> @78 @79 +@90 := LexLeanPreservation.Rust.wt_encList @0 +@92 := @34 @62 @64 +@106 := {c : @17} -> + {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @92 @66 @23) -> (xs : @70) -> @34 @60 @62 @77 @79 +@107 := @90 @1 +@108 := @43 @64 +@120 := {A : @18} -> + {α : @56} -> + {e : @58} -> {t : @59} -> (h : (x : @6) -> @108 @66 @23) -> (xs : @70) -> @43 @62 @77 @79 +@121 := @107 @2 +@123 := @50 @66 @23 +@131 := {α : @56} -> {e : @58} -> {t : @59} -> (h : (x : @6) -> @123) -> (xs : @70) -> @50 @77 @79 +@132 := @121 @3 +@142 := {e : (a._@._internal._hyg.#0 : @3) -> @57} -> + {t : @59} -> (h : (x : @3) -> @123) -> (xs : @5) -> @50 (@9 @20 @15) @79 +@143 := @132 @7 +@145 := (x : @3) -> @51 @23 +@147 := @50 (@10 @15) +@151 := {t : @59} -> (h : @145) -> (xs : @5) -> @147 @79 +@152 := @143 @12 +@156 := (h : (x : @3) -> @52) -> (xs : @5) -> @147 @14 +@158 := @152 @55 @6 +@160 := @50 @11 @14 +@161 := @7 @23 +@162 := @49 @23 +@164 := @50 @161 @12 +@165 := List.nil.{0} +@166 := List.cons.{0} +@167 := @165 @57 +@168 := @166 @57 +@170 := @168 @161 @167 +@172 := @168 @11 @170 +@173 := Nat +@176 := Prod.{0, 0} @173 @57 +@177 := 1 +@180 := Prod.mk.{0, 0} @173 @57 +@181 := @180 @177 +@182 := @181 @161 +@183 := 0 +@184 := @180 @183 +@185 := @184 @11 +@186 := @165 @176 +@187 := @166 @176 +@189 := @187 @185 @186 +@191 := @187 @182 @189 +@192 := Bool.false +@193 := LexLeanTarget.TargetSyntax.Function +@194 := LexLeanTarget.TargetSyntax.Program.functions +@195 := @194 @0 +@196 := @165 @173 +@197 := @165 @59 +@198 := LexLeanTarget.TargetSyntax.Ty.unit +@199 := LexLeanTarget.TargetSyntax.Value.unit +@202 := LexLeanTarget.TargetSyntax.Expr.value @198 @199 +@207 := LexLeanTarget.TargetSyntax.Function.mk @196 @197 @198 @202 +@212 := List.getD.{0} @193 @195 @183 @207 +@216 := fun (__e_n : @173) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@228 := @217 @0 +@234 := {c : @17} -> {A : @18} -> @228 @23 @15 @167 @197 +@235 := @227 @1 +@236 := @228 @1 +@240 := {A : @18} -> @236 @15 @167 @197 +@241 := @235 @2 +@242 := @236 @2 +@243 := @242 @167 +@244 := @243 @197 +@245 := @4 @57 +@246 := @4 @59 +@248 := @65 @20 @6 +@253 := @217 @71 @60 @62 @6 @23 +@254 := #8 +@257 := @217 @254 @71 @60 +@259 := @168 @62 @20 +@260 := @257 @259 +@261 := @166 @59 +@263 := @261 @64 @6 +@273 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {v : @57} -> {t : @59} -> {vs : @245} -> {ts : @246} -> (h : @248) -> (hs : @253) -> @260 @263 +@275 := LexLeanPreservation.Rust.wtl_cons @0 +@293 := {c : @17} -> + {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @245} -> + {ts : @246} -> (h : @92 @20 @6) -> (hs : @228 @60 @62 @6 @23) -> @228 @71 @60 @259 @263 +@294 := @275 @1 +@309 := {A : @18} -> + {v : @57} -> + {t : @59} -> + {vs : @245} -> {ts : @246} -> (h : @108 @20 @6) -> (hs : @236 @62 @6 @23) -> @236 @60 @259 @263 +@310 := @294 @2 +@312 := @50 @20 @6 +@314 := @242 @6 @23 +@322 := {v : @57} -> + {t : @59} -> {vs : @245} -> {ts : @246} -> (h : @312) -> (hs : @314) -> @242 @259 @263 +@323 := @310 @161 +@324 := @7 @64 +@326 := @50 @324 @6 +@327 := @7 @60 +@328 := @168 @327 +@336 := {t : @59} -> {vs : @245} -> {ts : @246} -> (h : @326) -> (hs : @314) -> @242 (@328 @20) @263 +@337 := @323 @12 +@338 := @7 @20 +@340 := @50 @338 @12 +@341 := @7 @62 +@342 := @168 @341 +@344 := @242 (@342 @20) +@345 := @261 @12 +@346 := @345 @6 +@351 := {vs : @245} -> {ts : @246} -> (h : @340) -> (hs : @314) -> @344 @346 +@352 := @337 @167 +@353 := @7 @6 +@355 := @50 @353 @12 +@356 := @243 @23 +@358 := @168 @324 @167 +@363 := {ts : @246} -> (h : @355) -> (hs : @356) -> @242 @358 @346 +@364 := @352 @197 +@366 := @168 @338 @167 +@367 := @242 @366 +@368 := @345 @197 +@371 := (h : @164) -> (hs : @244) -> @367 @368 +@372 := @364 @162 +@374 := @168 @353 @167 +@376 := @242 @374 @368 +@377 := (hs : @244) -> @376 +@378 := @372 @241 +@380 := @242 @170 @368 +@381 := @310 @11 +@382 := @10 @62 +@384 := @50 @382 @6 +@385 := @10 @71 +@386 := @168 @385 +@394 := {t : @59} -> {vs : @245} -> {ts : @246} -> (h : @384) -> (hs : @314) -> @242 (@386 @20) @263 +@395 := @381 @14 +@396 := @10 @64 +@398 := @50 @396 @14 +@399 := @10 @60 +@400 := @168 @399 +@402 := @242 (@400 @20) +@403 := @261 @14 +@404 := @403 @6 +@409 := {vs : @245} -> {ts : @246} -> (h : @398) -> (hs : @314) -> @402 @404 +@410 := @395 @170 +@411 := @10 @20 +@413 := @50 @411 @14 +@414 := @367 @23 +@416 := @168 @382 @358 +@417 := @242 @416 +@421 := {ts : @246} -> (h : @413) -> (hs : @414) -> @417 @404 +@422 := @410 @368 +@424 := @168 @396 @366 +@425 := @242 @424 +@426 := @403 @368 +@429 := (h : @160) -> (hs : @376) -> @425 @426 +@430 := @422 @158 +@432 := @168 @411 @374 +@433 := @242 @432 +@435 := (hs : @380) -> @433 @426 +@436 := @430 @378 +@437 := @242 @172 +@438 := @437 @426 +@439 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.denote +@441 := @439 @6 @23 +@442 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.__fits_0 +@444 := @442 @6 @23 +@448 := @7 (LexLeanStd.Text.joinWith @6 @23) +@451 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.root @6 @23 +@452 := Bool +@453 := Ne.{1} +@454 := LexLeanPreservation.Obs +@455 := @453 @454 +@456 := LexLeanPreservation.Rel +@459 := @455 (@456 @23 @15) +@460 := LexLeanPreservation.Obs.stuck +@463 := (f : @452) -> (v : @57) -> @459 @460 +@465 := LexLeanPreservation.Rust.rel_ne_stuck @444 +@472 := (v : @57) -> @455 (@456 (@442 @20 @6) @15) @460 +@473 := @465 @448 +@477 := @455 (@456 @444 @448) @460 +@478 := @4 @176 +@479 := LexLeanPreservation.Rust.FunSem +@480 := #9 +@486 := (n : @173) -> @479 @480 @254 @71 @15 @60 +@487 := Eq.{1} +@488 := Option.{0} +@489 := @488 @193 +@490 := @487 @489 +@497 := LexLeanRuntime.index (@4 @193) @193 (LexLeanRuntime.instIndexableList @193) +@501 := @490 (@497 (@194 @480) @60) +@502 := Option.some.{0} +@503 := @502 @193 +@504 := @503 @62 +@505 := @501 @504 +@506 := #10 +@510 := @217 @506 @480 @254 @62 +@511 := LexLeanTarget.TargetSyntax.Function.types +@512 := @511 @60 +@513 := @510 @512 +@514 := @488 @478 +@515 := @487 @514 +@516 := LexLeanTarget.TargetSemantics.bindAll +@517 := LexLeanTarget.TargetSyntax.Function.parameters +@522 := @515 (@516 (@517 @71) @60 @186) +@523 := @502 @478 +@524 := @523 @62 +@525 := @522 @524 +@526 := @488 @452 +@527 := @487 @526 +@528 := LexLeanPreservation.Rust.fnFallible +@529 := #11 +@532 := @527 (@528 @529 @480) +@533 := @502 @452 +@534 := @533 @62 +@535 := @532 @534 +@536 := LexLeanPreservation.RunConv +@537 := #13 +@541 := @536 @537 @506 @254 @62 +@543 := @455 @60 @460 +@544 := Exists.{1} +@545 := LexLeanPreservation.Rust.ROut +@546 := @544 @545 +@547 := And +@548 := LexLeanPreservation.Rust.RealizesFn +@552 := @547 (@548 @480 @254 @15) +@553 := LexLeanPreservation.Rust.RCI +@555 := @553 #15 +@556 := LexLeanPreservation.Rust.fnIdent +@557 := @556 @537 +@564 := (hne : @543) -> @546 (fun (ro : @545) => @552 (@555 @557 @529 @15)) +@579 := {p : @16} -> + {c : @17} -> + {A : @18} -> + {f : @173} -> + {fn : @193} -> + {args : @245} -> + {env : @478} -> + {F : @452} -> + {o : @454} -> + (hB : @486) -> + (hfn : @505) -> (hwt : @513) -> (hbind : @525) -> (hF : @535) -> (hA : @541) -> @564 +@581 := LexLeanPreservation.Rust.compose @0 +@582 := @479 @0 +@587 := (n : @173) -> @582 @254 @71 @15 @60 +@588 := @497 @195 +@591 := @490 (@588 @60) @504 +@595 := @228 @480 @254 @62 @512 +@596 := @536 @0 +@599 := @596 @506 @254 @62 +@613 := {c : @17} -> + {A : @18} -> + {f : @173} -> + {fn : @193} -> + {args : @245} -> + {env : @478} -> + {F : @452} -> + {o : @454} -> + (hB : @587) -> + (hfn : @591) -> (hwt : @595) -> (hbind : @525) -> (hF : @535) -> (hA : @599) -> @564 +@614 := @581 @1 +@615 := @582 @1 +@619 := (n : @173) -> @615 @71 @15 @60 +@622 := @236 @254 @62 @512 +@623 := @528 @1 +@626 := @527 (@623 @480) @534 +@627 := @553 @1 +@637 := (hbind : @525) -> + (hF : @626) -> (hA : @599) -> (hne : @543) -> @546 (fun (ro : @545) => @552 (@627 @557 @529 @15)) +@647 := {A : @18} -> + {f : @173} -> + {fn : @193} -> + {args : @245} -> + {env : @478} -> {F : @452} -> {o : @454} -> (hB : @619) -> (hfn : @591) -> (hwt : @622) -> @637 +@648 := @614 @2 +@650 := @615 @2 @15 +@652 := (n : @173) -> @650 @60 +@653 := @242 @62 +@654 := @653 @512 +@663 := {f : @173} -> + {fn : @193} -> + {args : @245} -> + {env : @478} -> {F : @452} -> {o : @454} -> (hB : @652) -> (hfn : @591) -> (hwt : @654) -> @637 +@664 := @648 @183 +@666 := (n : @173) -> @650 @183 +@667 := @588 @183 +@668 := @490 @667 +@669 := @668 @504 +@670 := @623 @183 +@671 := @527 @670 +@672 := @671 @534 +@673 := @596 @183 +@675 := @673 @254 @62 +@677 := @627 (@556 @183) +@685 := (hF : @672) -> (hA : @675) -> (hne : @543) -> @546 (fun (ro : @545) => @552 (@677 @529 @15)) +@694 := {fn : @193} -> + {args : @245} -> + {env : @478} -> + {F : @452} -> {o : @454} -> (hB : @666) -> (hfn : @669) -> (hwt : @654) -> (hbind : @525) -> @685 +@695 := @664 @212 +@697 := @668 (@503 @212) +@698 := @511 @212 +@699 := @653 @698 +@701 := @516 (@517 @212) +@713 := {args : @245} -> + {env : @478} -> + {F : @452} -> + {o : @454} -> + (hB : @666) -> (hfn : @697) -> (hwt : @699) -> (hbind : @515 (@701 @60 @186) @524) -> @685 +@714 := @695 @172 +@716 := @386 (@328 @167) +@718 := @242 @716 @698 +@724 := @168 (@10 @254) (@168 (@7 @71) @167) +@728 := @515 (@701 @724 @186) @524 +@734 := @168 (@10 @506) (@168 (@7 @480) @167) +@736 := @673 @734 @62 +@738 := @168 (@10 @537) +@739 := #12 +@758 := {env : @478} -> + {F : @452} -> + {o : @454} -> + (hB : @666) -> + (hfn : @697) -> + (hwt : @718) -> + (hbind : @728) -> + (hF : @672) -> + (hA : @736) -> + (hne : @543) -> @546 (fun (ro : @545) => @552 (@677 (@738 (@168 (@7 @739) @167)) @15)) +@759 := @714 @191 +@761 := @400 (@342 @167) +@763 := @242 @761 @698 +@774 := @515 (@701 @716 @186) (@523 (@187 (@181 @327) (@187 (@184 @385) @186))) +@780 := @168 (@10 @480) (@168 (@7 @254) @167) +@802 := {F : @452} -> + {o : @454} -> + (hB : @666) -> + (hfn : @697) -> + (hwt : @763) -> + (hbind : @774) -> + (hF : @672) -> + (hA : @673 @780 @62) -> + (hne : @543) -> @546 (fun (ro : @545) => @552 (@677 (@168 (@10 @739) (@168 (@7 @529) @167)) @15)) +@803 := @759 @192 +@804 := @417 @698 +@815 := @515 (@701 @761 @186) (@523 (@187 (@181 @341) (@187 (@184 @399) @186))) +@817 := @671 (@533 @192) +@819 := @673 @724 @62 +@820 := @548 @192 +@842 := {o : @454} -> + (hB : @666) -> + (hfn : @697) -> + (hwt : @804) -> + (hbind : @815) -> + (hF : @817) -> + (hA : @819) -> + (hne : @543) -> + @546 (fun (ro : @545) => @547 (@820 @254 @15) (@677 (@168 (@10 @529) (@168 (@7 @506) @167)) @15)) +@843 := @803 @441 +@844 := @425 @698 +@855 := @515 (@701 @416 @186) (@523 (@187 (@181 @324) (@187 (@184 @382) @186))) +@856 := @673 @716 +@858 := @439 @71 @60 +@859 := @856 @858 +@861 := @439 @254 @71 +@880 := (hB : @666) -> + (hfn : @697) -> + (hwt : @844) -> + (hbind : @855) -> + (hF : @817) -> + (hA : @859) -> + (hne : @455 @861 @460) -> + @546 (fun (ro : @545) => @547 (@820 (@439 @506 @480) @15) (@677 @734 @15)) +@881 := @843 @216 +@882 := @433 @698 +@893 := @515 (@701 @424 @186) (@523 (@187 (@181 @338) (@187 (@184 @396) @186))) +@894 := @673 @761 +@896 := @439 @60 @62 +@915 := (hfn : @697) -> + (hwt : @882) -> + (hbind : @893) -> + (hF : @817) -> + (hA : @894 @896) -> + (hne : @455 @858 @460) -> + @546 (fun (ro : @545) => @547 (@820 (@439 @480 @254) @15) (@677 @780 @15)) +@916 := Eq.refl.{1} +@919 := @881 (@916 @489 @667) +@920 := @437 @698 +@931 := @515 (@701 @432 @186) (@523 (@187 (@181 @353) (@187 (@184 @411) @186))) +@932 := @673 @416 +@934 := @439 @62 @64 +@950 := (hwt : @920) -> + (hbind : @931) -> + (hF : @817) -> + (hA : @932 @934) -> + (hne : @455 @896 @460) -> @546 (fun (ro : @545) => @547 (@820 @861 @15) (@677 @724 @15)) +@951 := @919 @436 +@953 := @701 @172 @186 +@956 := @515 @953 (@523 @191) +@957 := @673 @424 +@959 := @439 @64 @20 +@974 := (hbind : @956) -> + (hF : @817) -> + (hA : @957 @959) -> + (hne : @455 @934 @460) -> @546 (fun (ro : @545) => @547 (@820 @858 @15) (@677 @716 @15)) +@977 := @951 (@916 @514 @953) +@978 := @673 @432 +@980 := @439 @20 @6 +@994 := (hF : @817) -> + (hA : @978 @980) -> + (hne : @455 @959 @460) -> @546 (fun (ro : @545) => @547 (@820 @896 @15) (@677 @761 @15)) +@997 := @977 (@916 @526 @670) +@1011 := (hA : @673 @172 @441) -> + (hne : @455 @980 @460) -> @546 (fun (ro : @545) => @547 (@820 @934 @15) (@677 @416 @15)) +@1012 := @997 @451 +@1023 := (hne : @455 @441 @460) -> @546 (fun (ro : @545) => @547 (@820 @959 @15) (@677 @424 @15)) +@1024 := @1012 @473 +@1030 := @547 (@820 @980 @15) (@677 @432 @15) +@1032 := @546 (fun (ro : @545) => @1030) +@1034 := @546 (fun (__e_ro : @545) => @1030) +@1035 := LexLeanPreservation.Rust.RepresentableL +@1036 := @10 @23 +@1038 := @168 @25 @167 +@1041 := @1035 (@168 @1036 @1038) +@1042 := (__e_hrep : @1041) -> @1034 +@1043 := fun (__e_hrep : @1041) => @1024 +@1044 := (separator : @3) -> @1042 +@1045 := fun (separator : @3) => @1043 +@1046 := (pieces : @5) -> @1044 +@1047 := fun (pieces : @5) => @1045 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/RustStd.lean new file mode 100644 index 0000000000..71bc7e6124 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/RustStd.lean @@ -0,0 +1,51 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [(.list .bytes), .bytes], result := .bytes, + body := (.«match» .bytes (.call 1 [(.closure 2 [(.var 1)]), (.build .none (.option .bytes) []), (.var 0)]) [(.arm .some [2] (.var 2)), (.arm .none [] (.value .bytes (.bytes (ByteArray.mk #[]))))]) }, + { parameters := [0, 1, 2], types := [(.fn [(.option .bytes), .bytes] (.option .bytes)), (.option .bytes), (.list .bytes)], result := (.option .bytes), + body := (.«match» (.option .bytes) (.var 2) [(.arm .nil [] (.var 1)), (.arm .cons [3, 4] (.call 1 [(.var 0), (.apply (.var 0) [(.var 1), (.var 3)]), (.var 4)]))]) }, + { parameters := [0, 1, 2], types := [.bytes, (.option .bytes), .bytes], result := (.option .bytes), + body := (.«match» (.option .bytes) (.var 1) [(.arm .none [] (.build .some (.option .bytes) [(.var 2)])), (.arm .some [3] (.build .some (.option .bytes) [(.prim .append [(.prim .append [(.var 3), (.var 0)]), (.var 2)])]))]) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.enum (.fn 0) [{ number := 2, fields := [.bytes] }]), + (.apply 0 [(.option .bytes), .bytes] (.option .bytes) false [{ function := 2, captures := [.clone], functionFallible := false }]), + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := (.list .bytes) }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] .bytes (.mk [(.mk (.bind (.generated .holder 1)) none (.call (.function 1) [(.construct (.closure 0 2) [(.move (.generated .binding 1))]), (.construct (.none .bytes) []), (.move (.generated .binding 0))] false))] (.matchOn (.move (.generated .holder 1)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 2))) (.mk [] (.move (.generated .binding 2))))]))), + (.function (.generated .function 1) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 0) }, { pattern := (.bind (.generated .binding 1)), type := (.option .bytes) }, { pattern := (.bind (.generated .binding 2)), type := (.list .bytes) }] (.option .bytes) (.mk [(.mk (.bind (.generated .holder 2)) none (.move (.generated .binding 2)))] (.matchOn (.uncons (.generated .holder 2)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 1) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 3)) (some (.fn 0)) (.move (.generated .binding 0)))] (.apply (.generated .callee 3) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]))), + (.function (.generated .function 2) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := (.option .bytes) }, { pattern := (.bind (.generated .binding 2)), type := .bytes }] (.option .bytes) (.mk [(.mk (.bind (.generated .holder 4)) none (.move (.generated .binding 1)))] (.matchOn (.move (.generated .holder 4)) [(.mk .none (.mk [] (.construct .some [(.move (.generated .binding 2))]))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 7)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 0)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 8)) none (.move (.generated .binding 2)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false)))])))])))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [(([(.option .bytes), .bytes], (.option .bytes)), false)] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 1)) none (.call (.function 1) [(.construct (.closure 0 2) [(.move (.generated .binding 1))]), (.construct (.none .bytes) []), (.move (.generated .binding 0))] false))], (.matchOn (.move (.generated .holder 1)) [(.mk .none (.mk [] (.lit (.bytes (ByteArray.mk #[]))))), (.mk (.some (.bind (.generated .binding 2))) (.mk [] (.move (.generated .binding 2))))]), [(1, .bytes, (some 1)), (0, (.list .bytes), (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [(.option .bytes), .bytes] (.option .bytes)), (.option .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [.bytes]) (mask := [false]) (af := false) (ff := false) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfBNil (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(1, .bytes, (some 1)), (0, (.list .bytes), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bytes (ByteArray.mk #[])))) (Corr.mCons (Γ' := [(2, .bytes, (some 2)), (1, .bytes, (some 1)), (0, (.list .bytes), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 2))) (Corr.mNil) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl (Corr.bOfE (Corr.value rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun1 : FunOK program krate flags 1 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 2)) none (.move (.generated .binding 2)))], (.matchOn (.uncons (.generated .holder 2)) [(.mk .none (.mk [] (.move (.generated .binding 1)))), (.mk (.some (.tuple [(.bind (.generated .binding 3)), (.bind (.generated .binding 4))])) (.mk [] (.call (.function 1) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 3)) (some (.fn 0)) (.move (.generated .binding 0)))] (.apply (.generated .callee 3) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)))]), [(2, (.list .bytes), (some 2)), (1, (.option .bytes), (some 1)), (0, (.fn [(.option .bytes), .bytes] (.option .bytes)), (some 0))], rfl, rfl, + (Corr.matchArms (st := (.list .bytes)) (U := []) (view := true) (idx := [0, 1]) (Corr.var rfl rfl) (Corr.mCons (Γ' := [(2, (.list .bytes), (some 2)), (1, (.option .bytes), (some 1)), (0, (.fn [(.option .bytes), .bytes] (.option .bytes)), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.move (.generated .binding 1))) (Corr.mCons (Γ' := [(4, (.list .bytes), (some 4)), (3, .bytes, (some 3)), (2, (.list .bytes), (some 2)), (1, (.option .bytes), (some 1)), (0, (.fn [(.option .bytes), .bytes] (.option .bytes)), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 1) [(.clone (.generated .binding 0)), (.block (.mk [(.mk (.bind (.generated .callee 3)) (some (.fn 0)) (.move (.generated .binding 0)))] (.apply (.generated .callee 3) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false))), (.move (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callOps (ts := [(.fn [(.option .bytes), .bytes] (.option .bytes)), (.option .bytes), (.list .bytes)]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 3)) (some (.fn 0)) (.move (.generated .binding 0)))]) (tail := (.apply (.generated .callee 3) [(.move (.generated .binding 1)), (.move (.generated .binding 3))] false)) (Corr.apply (ps := [(.option .bytes), .bytes]) (af := false) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))) rfl rfl rfl rfl)) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.var rfl rfl))) rfl rfl rfl)⟩⟩ + +theorem fun2 : FunOK program krate flags 2 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 4)) none (.move (.generated .binding 1)))], (.matchOn (.move (.generated .holder 4)) [(.mk .none (.mk [] (.construct .some [(.move (.generated .binding 2))]))), (.mk (.some (.bind (.generated .binding 3))) (.mk [] (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 7)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 0)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 8)) none (.move (.generated .binding 2)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false)))])))]), [(2, .bytes, (some 2)), (1, (.option .bytes), (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [0, 1]) (Corr.var rfl rfl) (Corr.mCons (Γ' := [(2, .bytes, (some 2)), (1, (.option .bytes), (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.construct .some [(.move (.generated .binding 2))])) (Corr.mCons (Γ' := [(3, .bytes, (some 3)), (2, .bytes, (some 2)), (1, (.option .bytes), (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 7)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 0)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 8)) none (.move (.generated .binding 2)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false)))])) (Corr.mNil) rfl rfl rfl (Corr.build (ts := [.bytes]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 7)) none (.block (.mk [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 0)))] (.call (.runtime .appendBytes) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)))), (.mk (.bind (.generated .operand 8)) none (.move (.generated .binding 2)))]) (tail := (.call (.runtime .appendBytes) [(.move (.generated .operand 7)), (.move (.generated .operand 8))] false)) (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 5)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 6)) none (.move (.generated .binding 0)))]) (tail := (.call (.runtime .appendBytes) [(.move (.generated .operand 5)), (.move (.generated .operand 6))] false)) (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))) rfl)) rfl rfl rfl (Corr.build (ts := [.bytes]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl)) rfl rfl rfl)⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | 1 => exact fun1 + | 2 => exact fun2 + | _ + 3 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6.lean new file mode 100644 index 0000000000..859811b450 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6.lean @@ -0,0 +1,53 @@ +import LexLeanPreservation.Core +import LexLeanPreservation.Values +import LexLeanPreservation.Primitives +import LexLeanPreservation.Fixed +import LexLeanPreservation.Keys +import LexLeanPreservation.Templates +import LexLeanPreservation.Validate +import LexLeanStd.Text +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +set_option linter.unusedVariables false +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6 + +def __prog : _root_.LexLeanTarget.TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := (.option .nat), + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.«let» 4 .nat (.first (.call 1 [(.closure 2 [(.var 1), (.var 3), (.var 0), (.var 2)]), (.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.value .nat (.nat 0))])) (.cond (.call 3 [(.var 0), (.var 1), (.var 4)]) (.build .some (.option .nat) [(.var 4)]) (.build .none (.option .nat) []))))) }, + { parameters := [0, 1, 2], types := [(.fn [.nat] (.option .nat)), .nat, .nat], result := (.pair .nat .bool), + body := (.«match» (.pair .nat .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair .nat .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1, 2, 3, 4], types := [.bytes, .nat, .bytes, .nat, .nat], result := (.option .nat), + body := (.cond (.call 3 [(.var 2), (.var 0), (.var 4)]) (.build .none (.option .nat) []) (.cond (.prim .natLt [(.prim .natAdd [(.var 4), (.var 1)]), (.var 3)]) (.build .some (.option .nat) [(.prim .natAdd [(.var 4), (.value .nat (.nat 1))])]) (.build .none (.option .nat) []))) }, + { parameters := [0, 1, 2], types := [.bytes, .bytes, .nat], result := .bool, + body := (.«match» .bool (.prim .slice [(.var 0), (.var 2), (.prim .length [(.var 1)])]) [(.arm .some [3] (.prim .equal [(.var 3), (.var 1)])), (.arm .none [] (.build .false .bool []))]) }] } + +def __fits_3 (subject : ByteArray) (needle : ByteArray) (position : Nat) : Bool := + (((Bool.true && (Bool.true && (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (needle) : Nat) 18446744073709551616)) && Bool.true))) && Bool.true) && (match (_root_.LexLeanRuntime.slice (subject) (position) ((_root_.LexLeanRuntime.length (needle) : Nat)) : (Option ByteArray)) with | Option.some window => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) + +theorem __rel_3 (subject : ByteArray) (needle : ByteArray) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 3 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.bytes needle), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_3 subject needle position) (_root_.LexLeanTarget.TargetSyntax.Value.bool (LexLeanStd.Text.matchAt subject needle position))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_matchV (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.bytes) (fun (__a : (Option ByteArray)) => (match __a with | Option.some window => ((Bool.true && (Bool.true && Bool.true)) && Bool.true) | Option.none => (Bool.true && Bool.true))) (fun (__a : (Option ByteArray)) => _root_.LexLeanTarget.TargetSyntax.Value.bool (match __a with | Option.some window => (_root_.LexLeanRuntime.equal (window) (needle) : Bool) | Option.none => Bool.false)) (_root_.LexLeanRuntime.slice (subject) (position) ((_root_.LexLeanRuntime.length (needle) : Nat)) : (Option ByteArray)) (_root_.LexLeanPreservation.conv_prim (_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_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes needle)) _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.prim_slice_bytes subject position (_root_.LexLeanRuntime.length (needle) : Nat))) (fun (__a : (Option ByteArray)) _ => match __a with | Option.some window => (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_equal_bytes window needle))) | Option.none => (_root_.LexLeanPreservation.convA_miss rfl (_root_.LexLeanPreservation.convA_hit rfl rfl (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_false))))) + +def __fits_2 (needle : ByteArray) (size : Nat) (subject : ByteArray) (total : Nat) (position : Nat) : Bool := + (((Bool.true && (Bool.true && (Bool.true && Bool.true))) && (__fits_3 (subject) (needle) (position))) && (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Bool.true && Bool.true) else (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + size) 18446744073709551616)) && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.blt (position + size) total) then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))))) + +attribute [local irreducible] LexLeanStd.Text.matchAt in +theorem __rel_2 (needle : ByteArray) (size : Nat) (subject : ByteArray) (total : Nat) (position : Nat) : _root_.LexLeanPreservation.FunRel __prog 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes needle), (_root_.LexLeanTarget.TargetSyntax.Value.nat size), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat total), (_root_.LexLeanTarget.TargetSyntax.Value.nat position)] (_root_.LexLeanPreservation.Rel (__fits_2 needle size subject total position) ((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) ((if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))))))) := + _root_.LexLeanPreservation.funRel_intro rfl rfl (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then (Bool.true && Bool.true) else (((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + size) 18446744073709551616)) && (Bool.true && Bool.true)) && Bool.true) && (if (Nat.blt (position + size) total) then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))))) (LexLeanStd.Text.matchAt (subject) (needle) (position)) (_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_3 (subject) (needle) (position))) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)) (fun _ => (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (position + (1 : Nat)) 18446744073709551616)) && Bool.true) && Bool.true) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))) (Nat.blt (position + size) total) (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position size)) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natLt (position + size) total)) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd position (1 : Nat))) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none))))) + +def __fits_0 (subject : ByteArray) (needle : ByteArray) : Bool := + (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (subject) : Nat) 18446744073709551616)) && (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); (((Bool.true && Bool.true) && (Nat.blt (_root_.LexLeanRuntime.length (needle) : Nat) 18446744073709551616)) && (let size : Nat := (_root_.LexLeanRuntime.length (needle) : Nat); ((((Bool.true && (Bool.true && (Bool.true && (Bool.true && Bool.true)))) && (((Bool.true && (Bool.true && Bool.true)) && (Nat.blt (total + (1 : Nat)) 18446744073709551616)) && (Bool.true && Bool.true))) && (_root_.LexLeanPreservation.untilFits (fun (__p0 : Nat) => __fits_2 (needle) (size) (subject) (total) __p0) ((fun (position : Nat) => (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))))) ((total + (1 : Nat))) ((0 : Nat)))) && (let position : Nat := ((_root_.LexLeanCollections.iterateUntil ((fun (position : Nat) => (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))))) ((total + (1 : Nat))) ((0 : Nat)) : (Prod Nat Bool))).1; (((Bool.true && (Bool.true && (Bool.true && Bool.true))) && (__fits_3 (subject) (needle) (position))) && (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then ((Bool.true && Bool.true) && Bool.true) else (Bool.true && Bool.true))))))))) + +attribute [local irreducible] LexLeanStd.Text.matchAt in +theorem __rel_0 (subject : ByteArray) (needle : ByteArray) : _root_.LexLeanPreservation.FunRel __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.funRel_intro rfl rfl (let total : Nat := (_root_.LexLeanRuntime.length (subject) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes subject)) (let size : Nat := (_root_.LexLeanRuntime.length (needle) : Nat); _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) (_root_.LexLeanPreservation.prim_length_bytes needle)) (let position : Nat := ((_root_.LexLeanCollections.iterateUntil ((fun (position : Nat) => (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))))) ((total + (1 : Nat))) ((0 : Nat)) : (Prod Nat Bool))).1; _root_.LexLeanPreservation.conv_let (_root_.LexLeanPreservation.conv_first (_root_.LexLeanPreservation.conv_call (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_closure (_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))))) (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_prim (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil)) (_root_.LexLeanPreservation.prim_natAdd total (1 : Nat))) (_root_.LexLeanPreservation.convL_cons _root_.LexLeanPreservation.conv_value _root_.LexLeanPreservation.convL_nil))) (_root_.LexLeanPreservation.tpl_iterateUntil (es := _root_.LexLeanTarget.TargetSyntax.Value.nat) (_root_.LexLeanPreservation.optEnc _root_.LexLeanTarget.TargetSyntax.Value.nat) (fun _ => rfl) (_root_.LexLeanPreservation.encPair _root_.LexLeanTarget.TargetSyntax.Value.nat _root_.LexLeanTarget.TargetSyntax.Value.bool) (fun _ => rfl) ((fun (position : Nat) => (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat)))))) (fun (__p0 : Nat) => __fits_2 (needle) (size) (subject) (total) __p0) 2 [(_root_.LexLeanTarget.TargetSyntax.Value.bytes needle), (_root_.LexLeanTarget.TargetSyntax.Value.nat size), (_root_.LexLeanTarget.TargetSyntax.Value.bytes subject), (_root_.LexLeanTarget.TargetSyntax.Value.nat total)] (fun (__p0 : Nat) => __rel_2 (needle) (size) (subject) (total) __p0) (_root_.LexLeanCollections.iterateUntil ((fun (position : Nat) => (if (LexLeanStd.Text.matchAt (subject) (needle) (position)) then (Option.none : (Option Nat)) else (if (Nat.blt (position + size) total) then (Option.some ((position + (1 : Nat))) : (Option Nat)) else (Option.none : (Option Nat))))))) (fun _ => rfl) (fun _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (fun _ _ _ __h => by simp only [_root_.LexLeanCollections.iterateUntil, __h]) (p := __prog) (fi := 1) (ts := .nat) rfl ((total + (1 : Nat))) ((0 : Nat))))) (_root_.LexLeanPreservation.conv_cond (fun (__b : Bool) => (if __b then ((Bool.true && Bool.true) && Bool.true) else (Bool.true && Bool.true))) (fun (__b : Bool) => (_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (if __b then (Option.some (position) : (Option Nat)) else (Option.none : (Option Nat)))) (LexLeanStd.Text.matchAt (subject) (needle) (position)) (_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_3 (subject) (needle) (position))) (fun _ => (_root_.LexLeanPreservation.conv_build (_root_.LexLeanPreservation.convL_cons (_root_.LexLeanPreservation.conv_var rfl) _root_.LexLeanPreservation.convL_nil) _root_.LexLeanPreservation.construct_some)) (fun _ => (_root_.LexLeanPreservation.conv_build _root_.LexLeanPreservation.convL_nil _root_.LexLeanPreservation.construct_none)))))) + +def denote (subject : ByteArray) (needle : ByteArray) : _root_.LexLeanPreservation.Obs := + _root_.cond (__fits_0 subject needle) (_root_.LexLeanPreservation.Obs.value (((_root_.LexLeanPreservation.encOption _root_.LexLeanTarget.TargetSyntax.Value.nat) (LexLeanStd.Text.find subject needle)))) _root_.LexLeanPreservation.Obs.overflow + +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6 diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/Compose/RustStd.lex.tex b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/Compose/RustStd.lex.tex new file mode 100644 index 0000000000..abd4a490fb --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/Compose/RustStd.lex.tex @@ -0,0 +1,465 @@ +\begin{lexlean}{RustStd} +\title{Certificate E LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd} +\begin{coremodule} +imports [ + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6, + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd, + LexLeanPreservation.Compose +] + +theorem LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.root : @919 := @920 { + all: [LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.root], + class: false, + generated: false, + policy: exact{axioms: [Classical.choice, Quot.sound, propext]}, + transparency: semireducible +} + +@0 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.program +@1 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.krate +@2 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.flags +@3 := ByteArray +@4 := #2 +@5 := LexLeanTarget.TargetSyntax.Value.bytes +@6 := @5 @4 +@7 := LexLeanTarget.TargetSyntax.Ty.bytes +@8 := LexLeanTarget.TargetSyntax.Program +@9 := LexLeanPreservation.Rust.RCrate +@10 := LexLeanPreservation.Rust.Flags +@11 := LexLeanPreservation.Rust.WT +@12 := #3 +@14 := @11 @12 @4 +@15 := #1 +@16 := @14 @15 +@17 := #0 +@18 := @5 @17 +@24 := {p : @8} -> {c : @9} -> {A : @10} -> (b : @3) -> @16 @18 @7 +@26 := LexLeanPreservation.Rust.wt_bytes @0 +@27 := @11 @0 +@34 := {c : @9} -> {A : @10} -> (b : @3) -> @27 @4 @15 @18 @7 +@35 := @26 @1 +@36 := @27 @1 +@41 := {A : @10} -> (b : @3) -> @36 @15 @18 @7 +@42 := @35 @2 +@43 := @36 @2 +@46 := (b : @3) -> @43 @18 @7 +@47 := @42 @4 +@49 := @43 @6 @7 +@50 := @5 @15 +@51 := @42 @15 +@53 := @43 @50 @7 +@54 := LexLeanTarget.TargetSyntax.Value +@55 := List.nil.{0} +@56 := List.cons.{0} +@57 := @55 @54 +@58 := @56 @54 +@59 := @58 @50 +@60 := @59 @57 +@61 := @58 @6 +@62 := @61 @60 +@63 := Nat +@66 := Prod.{0, 0} @63 @54 +@67 := 1 +@70 := Prod.mk.{0, 0} @63 @54 +@71 := @70 @67 +@72 := @71 @50 +@73 := 0 +@74 := @70 @73 +@75 := @74 @6 +@76 := @55 @66 +@77 := @56 @66 +@79 := @77 @75 @76 +@81 := @77 @72 @79 +@82 := Bool.true +@83 := LexLeanTarget.TargetSyntax.Function +@84 := LexLeanTarget.TargetSyntax.Program.functions +@85 := @84 @0 +@86 := LexLeanTarget.TargetSyntax.Ty +@87 := @55 @63 +@88 := @55 @86 +@89 := LexLeanTarget.TargetSyntax.Ty.unit +@90 := LexLeanTarget.TargetSyntax.Value.unit +@93 := LexLeanTarget.TargetSyntax.Expr.value @89 @90 +@98 := LexLeanTarget.TargetSyntax.Function.mk @87 @88 @89 @93 +@103 := List.getD.{0} @83 @85 @73 @98 +@107 := fun (__e_n : @63) => + LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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 +@119 := @108 @0 +@125 := {c : @9} -> {A : @10} -> @119 @15 @17 @57 @88 +@126 := @118 @1 +@127 := @119 @1 +@131 := {A : @10} -> @127 @17 @57 @88 +@132 := @126 @2 +@133 := @127 @2 +@134 := @133 @57 +@135 := @134 @88 +@136 := List.{0} +@137 := @136 @54 +@138 := @136 @86 +@139 := #6 +@140 := @11 @139 +@141 := #5 +@142 := @140 @141 +@143 := #4 +@146 := @142 @143 @12 @4 +@147 := #7 +@152 := @108 @147 @139 @141 @4 @15 +@153 := #8 +@156 := @108 @153 @147 @139 +@158 := @58 @141 @12 +@159 := @156 @158 +@160 := @56 @86 +@162 := @160 @143 @4 +@172 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {v : @54} -> {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @146) -> (hs : @152) -> @159 @162 +@174 := LexLeanPreservation.Rust.wtl_cons @0 +@194 := {c : @9} -> + {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> + (h : @27 @141 @143 @12 @4) -> (hs : @119 @139 @141 @4 @15) -> @119 @147 @139 @158 @162 +@195 := @174 @1 +@211 := {A : @10} -> + {v : @54} -> + {t : @86} -> + {vs : @137} -> + {ts : @138} -> (h : @36 @143 @12 @4) -> (hs : @127 @141 @4 @15) -> @127 @139 @158 @162 +@212 := @195 @2 +@214 := @43 @12 @4 +@216 := @133 @4 @15 +@224 := {v : @54} -> + {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @214) -> (hs : @216) -> @133 @158 @162 +@225 := @212 @50 +@226 := @5 @143 +@227 := @43 @226 +@228 := @227 @4 +@229 := @5 @139 +@230 := @58 @229 +@232 := @133 (@230 @12) +@238 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @228) -> (hs : @216) -> @232 @162 +@239 := @225 @7 +@240 := @5 @12 +@242 := @43 @240 @7 +@243 := @5 @141 +@244 := @58 @243 +@246 := @133 (@244 @12) +@247 := @160 @7 +@248 := @247 @4 +@253 := {vs : @137} -> {ts : @138} -> (h : @242) -> (hs : @216) -> @246 @248 +@254 := @239 @57 +@255 := @134 @15 +@256 := @58 @226 +@257 := @256 @57 +@262 := {ts : @138} -> (h : @49) -> (hs : @255) -> @133 @257 @248 +@263 := @254 @88 +@264 := @58 @240 +@265 := @264 @57 +@266 := @133 @265 +@267 := @247 @88 +@270 := (h : @53) -> (hs : @135) -> @266 @267 +@271 := @263 @51 +@272 := @61 @57 +@274 := @133 @272 @267 +@275 := (hs : @135) -> @274 +@276 := @271 @132 +@278 := @133 @60 @267 +@279 := @212 @6 +@281 := @43 @243 @4 +@282 := @5 @147 +@283 := @58 @282 +@291 := {t : @86} -> {vs : @137} -> {ts : @138} -> (h : @281) -> (hs : @216) -> @133 (@283 @12) @162 +@292 := @279 @7 +@298 := {vs : @137} -> {ts : @138} -> (h : @227 @7) -> (hs : @216) -> @232 @248 +@299 := @292 @60 +@300 := @266 @15 +@301 := @244 @257 +@302 := @133 @301 +@306 := {ts : @138} -> (h : @242) -> (hs : @300) -> @302 @248 +@307 := @299 @267 +@308 := @256 @265 +@309 := @133 @308 +@310 := @247 @267 +@313 := (h : @49) -> (hs : @274) -> @309 @310 +@314 := @307 @47 +@315 := @264 @272 +@316 := @133 @315 +@318 := (hs : @278) -> @316 @310 +@319 := @314 @276 +@320 := @133 @62 +@321 := @320 @310 +@322 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.denote +@324 := @322 @4 @15 +@325 := LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.root @4 @15 +@339 := Bool +@340 := Ne.{1} +@341 := LexLeanPreservation.Obs +@342 := @340 @341 +@343 := LexLeanPreservation.Rel +@346 := @342 (@343 @15 @17) +@347 := LexLeanPreservation.Obs.stuck +@350 := (f : @339) -> (v : @54) -> @346 @347 +@352 := LexLeanPreservation.Rust.rel_ne_stuck @327 +@359 := (v : @54) -> @342 (@343 (@325 @12 @4) @17) @347 +@360 := @352 @335 +@364 := @342 (@343 @327 @335) @347 +@365 := @136 @66 +@366 := LexLeanPreservation.Rust.FunSem +@367 := #9 +@373 := (n : @63) -> @366 @367 @153 @147 @17 @139 +@374 := Eq.{1} +@375 := Option.{0} +@376 := @375 @83 +@377 := @374 @376 +@384 := LexLeanRuntime.index (@136 @83) @83 (LexLeanRuntime.instIndexableList @83) +@388 := @377 (@384 (@84 @367) @139) +@389 := Option.some.{0} +@390 := @389 @83 +@391 := @390 @141 +@392 := @388 @391 +@393 := #10 +@397 := @108 @393 @367 @153 @141 +@398 := LexLeanTarget.TargetSyntax.Function.types +@399 := @398 @139 +@400 := @397 @399 +@401 := @375 @365 +@402 := @374 @401 +@403 := LexLeanTarget.TargetSemantics.bindAll +@404 := LexLeanTarget.TargetSyntax.Function.parameters +@409 := @402 (@403 (@404 @147) @139 @76) +@410 := @389 @365 +@411 := @410 @141 +@412 := @409 @411 +@413 := @375 @339 +@414 := @374 @413 +@415 := LexLeanPreservation.Rust.fnFallible +@416 := #11 +@419 := @414 (@415 @416 @367) +@420 := @389 @339 +@421 := @420 @141 +@422 := @419 @421 +@423 := LexLeanPreservation.RunConv +@424 := #13 +@428 := @423 @424 @393 @153 @141 +@430 := @342 @139 @347 +@431 := Exists.{1} +@432 := LexLeanPreservation.Rust.ROut +@433 := @431 @432 +@434 := And +@435 := LexLeanPreservation.Rust.RealizesFn +@439 := @434 (@435 @367 @153 @17) +@440 := LexLeanPreservation.Rust.RCI +@442 := @440 #15 +@443 := LexLeanPreservation.Rust.fnIdent +@444 := @443 @424 +@451 := (hne : @430) -> @433 (fun (ro : @432) => @439 (@442 @444 @416 @17)) +@466 := {p : @8} -> + {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @365} -> + {F : @339} -> + {o : @341} -> + (hB : @373) -> + (hfn : @392) -> (hwt : @400) -> (hbind : @412) -> (hF : @422) -> (hA : @428) -> @451 +@468 := LexLeanPreservation.Rust.compose @0 +@469 := @366 @0 +@474 := (n : @63) -> @469 @153 @147 @17 @139 +@475 := @384 @85 +@478 := @377 (@475 @139) @391 +@482 := @119 @367 @153 @141 @399 +@483 := @423 @0 +@486 := @483 @393 @153 @141 +@500 := {c : @9} -> + {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @365} -> + {F : @339} -> + {o : @341} -> + (hB : @474) -> + (hfn : @478) -> (hwt : @482) -> (hbind : @412) -> (hF : @422) -> (hA : @486) -> @451 +@501 := @468 @1 +@502 := @469 @1 +@506 := (n : @63) -> @502 @147 @17 @139 +@509 := @127 @153 @141 @399 +@510 := @415 @1 +@513 := @414 (@510 @367) @421 +@514 := @440 @1 +@524 := (hbind : @412) -> + (hF : @513) -> (hA : @486) -> (hne : @430) -> @433 (fun (ro : @432) => @439 (@514 @444 @416 @17)) +@534 := {A : @10} -> + {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @365} -> {F : @339} -> {o : @341} -> (hB : @506) -> (hfn : @478) -> (hwt : @509) -> @524 +@535 := @501 @2 +@537 := @502 @2 @17 +@539 := (n : @63) -> @537 @139 +@540 := @133 @141 +@541 := @540 @399 +@550 := {f : @63} -> + {fn : @83} -> + {args : @137} -> + {env : @365} -> {F : @339} -> {o : @341} -> (hB : @539) -> (hfn : @478) -> (hwt : @541) -> @524 +@551 := @535 @73 +@553 := (n : @63) -> @537 @73 +@554 := @475 @73 +@555 := @377 @554 +@556 := @555 @391 +@557 := @510 @73 +@558 := @414 @557 +@559 := @558 @421 +@560 := @483 @73 +@562 := @560 @153 @141 +@564 := @514 (@443 @73) +@572 := (hF : @559) -> (hA : @562) -> (hne : @430) -> @433 (fun (ro : @432) => @439 (@564 @416 @17)) +@581 := {fn : @83} -> + {args : @137} -> + {env : @365} -> + {F : @339} -> {o : @341} -> (hB : @553) -> (hfn : @556) -> (hwt : @541) -> (hbind : @412) -> @572 +@582 := @551 @103 +@584 := @555 (@390 @103) +@585 := @398 @103 +@586 := @540 @585 +@588 := @403 (@404 @103) +@600 := {args : @137} -> + {env : @365} -> + {F : @339} -> + {o : @341} -> + (hB : @553) -> (hfn : @584) -> (hwt : @586) -> (hbind : @402 (@588 @139 @76) @411) -> @572 +@601 := @582 @62 +@603 := @283 (@230 @57) +@605 := @133 @603 @585 +@607 := @58 (@5 @153) +@609 := @607 (@283 @57) +@613 := @402 (@588 @609 @76) @411 +@615 := @58 (@5 @393) +@617 := @58 (@5 @367) +@619 := @615 (@617 @57) +@621 := @560 @619 @141 +@623 := @58 (@5 @424) +@626 := @58 (@5 #12) +@643 := {env : @365} -> + {F : @339} -> + {o : @341} -> + (hB : @553) -> + (hfn : @584) -> + (hwt : @605) -> + (hbind : @613) -> + (hF : @559) -> + (hA : @621) -> (hne : @430) -> @433 (fun (ro : @432) => @439 (@564 (@623 (@626 @57)) @17)) +@644 := @601 @81 +@646 := @230 (@244 @57) +@648 := @133 @646 @585 +@659 := @402 (@588 @603 @76) (@410 (@77 (@71 @229) (@77 (@74 @282) @76))) +@661 := @617 (@607 @57) +@663 := @560 @661 @141 +@665 := @58 (@5 @416) +@681 := {F : @339} -> + {o : @341} -> + (hB : @553) -> + (hfn : @584) -> + (hwt : @648) -> + (hbind : @659) -> + (hF : @559) -> + (hA : @663) -> (hne : @430) -> @433 (fun (ro : @432) => @439 (@564 (@626 (@665 @57)) @17)) +@682 := @644 @82 +@683 := @302 @585 +@694 := @402 (@588 @646 @76) (@410 (@77 (@71 @243) (@77 (@74 @229) @76))) +@696 := @558 (@420 @82) +@698 := @560 @609 @141 +@699 := @435 @82 +@717 := {o : @341} -> + (hB : @553) -> + (hfn : @584) -> + (hwt : @683) -> + (hbind : @694) -> + (hF : @696) -> + (hA : @698) -> + (hne : @430) -> @433 (fun (ro : @432) => @434 (@699 @153 @17) (@564 (@665 (@615 @57)) @17)) +@718 := @682 @324 +@719 := @309 @585 +@730 := @402 (@588 @301 @76) (@410 (@77 (@71 @226) (@77 (@74 @243) @76))) +@731 := @560 @603 +@733 := @322 @147 @139 +@734 := @731 @733 +@736 := @322 @153 @147 +@755 := (hB : @553) -> + (hfn : @584) -> + (hwt : @719) -> + (hbind : @730) -> + (hF : @696) -> + (hA : @734) -> + (hne : @342 @736 @347) -> + @433 (fun (ro : @432) => @434 (@699 (@322 @393 @367) @17) (@564 @619 @17)) +@756 := @718 @107 +@757 := @316 @585 +@768 := @402 (@588 @308 @76) (@410 (@77 (@71 @240) (@77 (@74 @226) @76))) +@769 := @560 @646 +@771 := @322 @139 @141 +@790 := (hfn : @584) -> + (hwt : @757) -> + (hbind : @768) -> + (hF : @696) -> + (hA : @769 @771) -> + (hne : @342 @733 @347) -> + @433 (fun (ro : @432) => @434 (@699 (@322 @367 @153) @17) (@564 @661 @17)) +@791 := Eq.refl.{1} +@794 := @756 (@791 @376 @554) +@795 := @320 @585 +@806 := @402 (@588 @315 @76) (@410 (@77 (@71 @6) (@77 (@74 @240) @76))) +@807 := @560 @301 +@809 := @322 @141 @143 +@825 := (hwt : @795) -> + (hbind : @806) -> + (hF : @696) -> + (hA : @807 @809) -> + (hne : @342 @771 @347) -> @433 (fun (ro : @432) => @434 (@699 @736 @17) (@564 @609 @17)) +@826 := @794 @319 +@828 := @588 @62 @76 +@831 := @402 @828 (@410 @81) +@832 := @560 @308 +@834 := @322 @143 @12 +@849 := (hbind : @831) -> + (hF : @696) -> + (hA : @832 @834) -> + (hne : @342 @809 @347) -> @433 (fun (ro : @432) => @434 (@699 @733 @17) (@564 @603 @17)) +@852 := @826 (@791 @401 @828) +@853 := @560 @315 +@855 := @322 @12 @4 +@869 := (hF : @696) -> + (hA : @853 @855) -> + (hne : @342 @834 @347) -> @433 (fun (ro : @432) => @434 (@699 @771 @17) (@564 @646 @17)) +@872 := @852 (@791 @413 @557) +@886 := (hA : @560 @62 @324) -> + (hne : @342 @855 @347) -> @433 (fun (ro : @432) => @434 (@699 @809 @17) (@564 @301 @17)) +@887 := @872 @338 +@898 := (hne : @342 @324 @347) -> @433 (fun (ro : @432) => @434 (@699 @834 @17) (@564 @308 @17)) +@899 := @887 @360 +@905 := @434 (@699 @855 @17) (@564 @315 @17) +@907 := @433 (fun (ro : @432) => @905) +@909 := @433 (fun (__e_ro : @432) => @905) +@914 := LexLeanPreservation.Rust.RepresentableL (@59 (@58 @18 @57)) +@915 := (__e_hrep : @914) -> @909 +@916 := fun (__e_hrep : @914) => @899 +@917 := (needle : @3) -> @915 +@918 := fun (needle : @3) => @916 +@919 := (subject : @3) -> @917 +@920 := fun (subject : @3) => @918 +\end{coremodule} +\end{lexlean} diff --git a/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/RustStd.lean b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/RustStd.lean new file mode 100644 index 0000000000..7255569f88 --- /dev/null +++ b/stdlib/expected/verify/preserve/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/RustStd.lean @@ -0,0 +1,59 @@ +import LexLeanPreservation.RustSound +set_option autoImplicit false +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 +set_option synthInstance.maxHeartbeats 0 +namespace LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd +open LexLeanTarget LexLeanPreservation.Rust + +noncomputable def program : TargetSyntax.Program := + { adts := [], functions := [ + { parameters := [0, 1], types := [.bytes, .bytes], result := (.option .nat), + body := (.«let» 2 .nat (.prim .length [(.var 0)]) (.«let» 3 .nat (.prim .length [(.var 1)]) (.«let» 4 .nat (.first (.call 1 [(.closure 2 [(.var 1), (.var 3), (.var 0), (.var 2)]), (.prim .natAdd [(.var 2), (.value .nat (.nat 1))]), (.value .nat (.nat 0))])) (.cond (.call 3 [(.var 0), (.var 1), (.var 4)]) (.build .some (.option .nat) [(.var 4)]) (.build .none (.option .nat) []))))) }, + { parameters := [0, 1, 2], types := [(.fn [.nat] (.option .nat)), .nat, .nat], result := (.pair .nat .bool), + body := (.«match» (.pair .nat .bool) (.var 1) [(.arm .zero [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .false .bool [])])), (.arm .succ [3] (.«match» (.pair .nat .bool) (.apply (.var 0) [(.var 2)]) [(.arm .none [] (.build .pair (.pair .nat .bool) [(.var 2), (.build .true .bool [])])), (.arm .some [4] (.call 1 [(.var 0), (.var 3), (.var 4)]))]))]) }, + { parameters := [0, 1, 2, 3, 4], types := [.bytes, .nat, .bytes, .nat, .nat], result := (.option .nat), + body := (.cond (.call 3 [(.var 2), (.var 0), (.var 4)]) (.build .none (.option .nat) []) (.cond (.prim .natLt [(.prim .natAdd [(.var 4), (.var 1)]), (.var 3)]) (.build .some (.option .nat) [(.prim .natAdd [(.var 4), (.value .nat (.nat 1))])]) (.build .none (.option .nat) []))) }, + { parameters := [0, 1, 2], types := [.bytes, .bytes, .nat], result := .bool, + body := (.«match» .bool (.prim .slice [(.var 0), (.var 2), (.prim .length [(.var 1)])]) [(.arm .some [3] (.prim .equal [(.var 3), (.var 1)])), (.arm .none [] (.build .false .bool []))]) }] } + +noncomputable def krate : RustSyntax.Crate := + ({ profile := .std, items := [ + (.enum (.fn 0) [{ number := 2, fields := [.bytes, .nat, .bytes, .nat] }]), + (.apply 0 [.nat] (.option .nat) true [{ function := 2, captures := [.clone, .copy, .clone, .copy], functionFallible := true }]), + (.function (.generated .function 0) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .bytes }] (.fallible (.option .nat)) (.mk [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 1)), (.copy (.generated .binding 3)), (.clone (.generated .binding 0)), (.copy (.generated .binding 2))]), (.block (.mk [(.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 5)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 4)), (.move (.generated .operand 5))] true))), (.lit (.nat 0))] true))] (.move (.generated .part 3)))))] (.cond (.call (.function 3) [(.move (.generated .binding 0)), (.move (.generated .binding 1)), (.copy (.generated .binding 4))] false) (.mk [] (.succeed (.construct .some [(.copy (.generated .binding 4))]))) (.mk [] (.succeed (.construct (.none .nat) [])))))), + (.function (.generated .function 1) [{ pattern := (.bind (.generated .binding 0)), type := (.fn 0) }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .nat }] (.fallible (.pair .nat .bool)) (.mk [(.mk (.bind (.generated .holder 6)) none (.copy (.generated .binding 1)))] (.cond (.isZero (.generated .holder 6)) (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 6))), (.mk (.bind (.generated .holder 8)) none (.block (.mk [(.mk (.bind (.generated .callee 7)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 7) [(.copy (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 8)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))]))))), + (.function (.generated .function 2) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .nat }, { pattern := (.bind (.generated .binding 2)), type := .bytes }, { pattern := (.bind (.generated .binding 3)), type := .nat }, { pattern := (.bind (.generated .binding 4)), type := .nat }] (.fallible (.option .nat)) (.mk [] (.cond (.call (.function 3) [(.move (.generated .binding 2)), (.move (.generated .binding 0)), (.copy (.generated .binding 4))] false) (.mk [] (.succeed (.construct (.none .nat) []))) (.mk [(.mk (.bind (.generated .operand 11)) none (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] true)))), (.mk (.bind (.generated .operand 12)) none (.copy (.generated .binding 3)))] (.cond (.call (.runtime .natLt) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 14)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 13)), (.move (.generated .operand 14))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) [])))))))), + (.function (.generated .function 3) [{ pattern := (.bind (.generated .binding 0)), type := .bytes }, { pattern := (.bind (.generated .binding 1)), type := .bytes }, { pattern := (.bind (.generated .binding 2)), type := .nat }] .bool (.mk [(.mk (.bind (.generated .holder 19)) none (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 17)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 18)) none (.block (.mk [(.mk (.bind (.generated .operand 15)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 15))] false))))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 16)), (.move (.generated .operand 17)), (.move (.generated .operand 18))] false))))] (.matchOn (.move (.generated .holder 19)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 3))) (.mk [(.mk (.bind (.generated .operand 20)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 21)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false)))])))] } : LexLeanTarget.RustSyntax.Crate) + +def flags : Flags := [(([.nat], (.option .nat)), true)] + +theorem fun0 : FunOK program krate flags 0 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .binding 2)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)))), (.mk (.bind (.generated .binding 3)) (some .nat) (.block (.mk [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)))), (.mk (.bind (.generated .binding 4)) (some .nat) (.block (.mk [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 1)), (.copy (.generated .binding 3)), (.clone (.generated .binding 0)), (.copy (.generated .binding 2))]), (.block (.mk [(.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 5)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 4)), (.move (.generated .operand 5))] true))), (.lit (.nat 0))] true))] (.move (.generated .part 3)))))], (.cond (.call (.function 3) [(.move (.generated .binding 0)), (.move (.generated .binding 1)), (.copy (.generated .binding 4))] false) (.mk [] (.succeed (.construct .some [(.copy (.generated .binding 4))]))) (.mk [] (.succeed (.construct (.none .nat) [])))), [(1, .bytes, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 1)) none (.clone (.generated .binding 0)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 1))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 2)) none (.clone (.generated .binding 1)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 2))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl (Corr.letBind (Corr.eOfB (lets := [(.mk (.tuple [(.bind (.generated .part 3)), .wild]) none (.call (.function 1) [(.construct (.closure 0 2) [(.clone (.generated .binding 1)), (.copy (.generated .binding 3)), (.clone (.generated .binding 0)), (.copy (.generated .binding 2))]), (.block (.mk [(.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 5)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 4)), (.move (.generated .operand 5))] true))), (.lit (.nat 0))] true))]) (tail := (.move (.generated .part 3))) (Corr.first (ta := .nat) (tb := .bool) (Corr.eOfBNil (Corr.callOps (ts := [(.fn [.nat] (.option .nat)), .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.eOfBNil (Corr.closure (caps := [.bytes, .nat, .bytes, .nat]) (mask := [false, false, false, false]) (af := true) (ff := true) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil)))))) rfl rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 4)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 5)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 4)), (.move (.generated .operand 5))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lCons (Corr.value rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl)) rfl)) rfl (Corr.cond (lc := []) (ce := (.call (.function 3) [(.move (.generated .binding 0)), (.move (.generated .binding 1)), (.copy (.generated .binding 4))] false)) (lk := []) (Corr.callOps (ts := [.bytes, .bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct .some [(.copy (.generated .binding 4))]))) (lb := []) (tb := (.succeed (.construct (.none .nat) []))) (Corr.fOfB (Corr.build (ts := [.nat]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl)) (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)))))))⟩⟩ + +theorem fun1 : FunOK program krate flags 1 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 6)) none (.copy (.generated .binding 1)))], (.cond (.isZero (.generated .holder 6)) (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (.mk [(.mk (.bind (.generated .binding 3)) none (.predecessor (.generated .holder 6))), (.mk (.bind (.generated .holder 8)) none (.block (.mk [(.mk (.bind (.generated .callee 7)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 7) [(.copy (.generated .binding 2))] true))))] (.matchOn (.move (.generated .holder 8)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))]))), [(2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))], rfl, rfl, + (Corr.matchNat (sl := (some 3)) (Corr.var rfl rfl) rfl rfl rfl (Corr.kIf (la := []) (ta := (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool false))))) (lb := [(.mk (.bind (.generated .holder 8)) none (.block (.mk [(.mk (.bind (.generated .callee 7)) (some (.fn 0)) (.clone (.generated .binding 0)))] (.apply (.generated .callee 7) [(.copy (.generated .binding 2))] true))))]) (tb := (.matchOn (.move (.generated .holder 8)) [(.mk .none (.mk [] (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true)))))), (.mk (.some (.bind (.generated .binding 4))) (.mk [] (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)))])) (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil)))))) (Corr.matchArms (st := (.option .nat)) (U := []) (view := false) (idx := [0, 1]) (Corr.eOfB (lets := [(.mk (.bind (.generated .callee 7)) (some (.fn 0)) (.clone (.generated .binding 0)))]) (tail := (.apply (.generated .callee 7) [(.copy (.generated .binding 2))] true)) (Corr.apply (ps := [.nat]) (af := true) (Corr.var rfl rfl) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))) rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(3, .nat, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))]) (j := 0) (loads := []) (lets := []) (tail := (.succeed (.pair (.copy (.generated .binding 2)) (.lit (.bool true))))) (Corr.mCons (Γ' := [(4, .nat, (some 4)), (3, .nat, (some 3)), (2, .nat, (some 2)), (1, .nat, (some 1)), (0, (.fn [.nat] (.option .nat)), (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.call (.function 1) [(.move (.generated .binding 0)), (.copy (.generated .binding 3)), (.copy (.generated .binding 4))] false)) (Corr.mNil) rfl rfl rfl (Corr.callF (ts := [(.fn [.nat] (.option .nat)), .nat, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl)) rfl rfl rfl (Corr.fOfB (Corr.bOfE (Corr.buildPair (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.buildConst rfl) (Corr.lNil))))))) rfl rfl rfl)))⟩⟩ + +theorem fun2 : FunOK program krate flags 2 := + ⟨_, rfl, .inl ⟨_, _, [], (.cond (.call (.function 3) [(.move (.generated .binding 2)), (.move (.generated .binding 0)), (.copy (.generated .binding 4))] false) (.mk [] (.succeed (.construct (.none .nat) []))) (.mk [(.mk (.bind (.generated .operand 11)) none (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] true)))), (.mk (.bind (.generated .operand 12)) none (.copy (.generated .binding 3)))] (.cond (.call (.runtime .natLt) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 14)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 13)), (.move (.generated .operand 14))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) [])))))), [(4, .nat, (some 4)), (3, .nat, (some 3)), (2, .bytes, (some 2)), (1, .nat, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.cond (lc := []) (ce := (.call (.function 3) [(.move (.generated .binding 2)), (.move (.generated .binding 0)), (.copy (.generated .binding 4))] false)) (lk := []) (Corr.callOps (ts := [.bytes, .bytes, .nat]) (Corr.opsOfL (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lCons (Corr.var rfl rfl) (Corr.lNil))))) rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct (.none .nat) []))) (lb := [(.mk (.bind (.generated .operand 11)) none (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] true)))), (.mk (.bind (.generated .operand 12)) none (.copy (.generated .binding 3)))]) (tb := (.cond (.call (.runtime .natLt) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false) (.mk [] (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 14)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 13)), (.move (.generated .operand 14))] true)))]))) (.mk [] (.succeed (.construct (.none .nat) []))))) (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl)) (Corr.cond (lc := [(.mk (.bind (.generated .operand 11)) none (.block (.mk [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] true)))), (.mk (.bind (.generated .operand 12)) none (.copy (.generated .binding 3)))]) (ce := (.call (.runtime .natLt) [(.move (.generated .operand 11)), (.move (.generated .operand 12))] false)) (lk := []) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 9)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 10)) none (.copy (.generated .binding 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 9)), (.move (.generated .operand 10))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl) (Corr.kIf (la := []) (ta := (.succeed (.construct .some [(.block (.mk [(.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 14)) none (.lit (.nat 1)))] (.call (.runtime .natAdd) [(.move (.generated .operand 13)), (.move (.generated .operand 14))] true)))]))) (lb := []) (tb := (.succeed (.construct (.none .nat) []))) (Corr.fOfB (Corr.build (ts := [.nat]) (mask := [false]) (Corr.opsOfL (Corr.lCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 13)) none (.copy (.generated .binding 4))), (.mk (.bind (.generated .operand 14)) none (.lit (.nat 1)))]) (tail := (.call (.runtime .natAdd) [(.move (.generated .operand 13)), (.move (.generated .operand 14))] true)) (Corr.prim (ts := [.nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.value rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.lNil))) rfl)) (Corr.fOfB (Corr.build (ts := []) (mask := []) (Corr.opsNil) rfl))))))⟩⟩ + +theorem fun3 : FunOK program krate flags 3 := + ⟨_, rfl, .inl ⟨_, _, [(.mk (.bind (.generated .holder 19)) none (.block (.mk [(.mk (.bind (.generated .operand 16)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 17)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 18)) none (.block (.mk [(.mk (.bind (.generated .operand 15)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 15))] false))))] (.call (.runtime .sliceBytes) [(.move (.generated .operand 16)), (.move (.generated .operand 17)), (.move (.generated .operand 18))] false))))], (.matchOn (.move (.generated .holder 19)) [(.mk .none (.mk [] (.lit (.bool false)))), (.mk (.some (.bind (.generated .binding 3))) (.mk [(.mk (.bind (.generated .operand 20)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 21)) none (.move (.generated .binding 1)))] (.call (.runtime .equal) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false)))]), [(2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))], rfl, rfl, + (Corr.matchArms (st := (.option .bytes)) (U := []) (view := false) (idx := [1, 0]) (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 16)) none (.move (.generated .binding 0))), (.mk (.bind (.generated .operand 17)) none (.copy (.generated .binding 2))), (.mk (.bind (.generated .operand 18)) none (.block (.mk [(.mk (.bind (.generated .operand 15)) none (.clone (.generated .binding 1)))] (.call (.runtime .lengthBytes) [(.move (.generated .operand 15))] false))))]) (tail := (.call (.runtime .sliceBytes) [(.move (.generated .operand 16)), (.move (.generated .operand 17)), (.move (.generated .operand 18))] false)) (Corr.prim (ts := [.bytes, .nat, .nat]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.eOfB (lets := [(.mk (.bind (.generated .operand 15)) none (.clone (.generated .binding 1)))]) (tail := (.call (.runtime .lengthBytes) [(.move (.generated .operand 15))] false)) (Corr.prim (ts := [.bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) (Corr.mCons (Γ' := [(2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 1) (loads := []) (lets := []) (tail := (.lit (.bool false))) (Corr.mCons (Γ' := [(3, .bytes, (some 3)), (2, .nat, (some 2)), (1, .bytes, (some 1)), (0, .bytes, (some 0))]) (j := 0) (loads := []) (lets := [(.mk (.bind (.generated .operand 20)) none (.move (.generated .binding 3))), (.mk (.bind (.generated .operand 21)) none (.move (.generated .binding 1)))]) (tail := (.call (.runtime .equal) [(.move (.generated .operand 20)), (.move (.generated .operand 21))] false)) (Corr.mNil) rfl rfl rfl (Corr.prim (ts := [.bytes, .bytes]) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsCons (Corr.var rfl rfl) (Corr.opsNil) rfl rfl) rfl rfl) rfl rfl rfl rfl rfl rfl)) rfl rfl rfl (Corr.bOfE (Corr.buildConst rfl))) rfl rfl rfl)⟩⟩ + +theorem crate_ok : CrateOK program krate flags := by + intro f fn h + match f with + | 0 => exact fun0 + | 1 => exact fun1 + | 2 => exact fun2 + | 3 => exact fun3 + | _ + 4 => simp [program, index_eq] at h + +/-- 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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd diff --git a/stdlib/expected/verify/preserve/audit.txt b/stdlib/expected/verify/preserve/audit.txt new file mode 100644 index 0000000000..bef5d07e80 --- /dev/null +++ b/stdlib/expected/verify/preserve/audit.txt @@ -0,0 +1,7884 @@ +'LexLeanPreservation.Obs' does not depend on any axioms +'LexLeanPreservation.obs.match_1' does not depend on any axioms +'LexLeanPreservation.obs' does not depend on any axioms +'LexLeanPreservation.Conv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.ConvA' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.ObsL' does not depend on any axioms +'LexLeanPreservation.obsL.match_1' does not depend on any axioms +'LexLeanPreservation.obsL' does not depend on any axioms +'LexLeanPreservation.ConvL' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.FunRel' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Obs._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.Obs._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.Obs.casesOn' does not depend on any axioms +'LexLeanPreservation.Obs.ctorElimType' does not depend on any axioms +'LexLeanPreservation.Obs.ctorIdx' does not depend on any axioms +'LexLeanPreservation.Obs.ctorElim' does not depend on any axioms +'LexLeanPreservation.Obs.overflow.elim' does not depend on any axioms +'LexLeanPreservation.Obs.stuck.elim' does not depend on any axioms +'LexLeanPreservation.Obs.value.elim' does not depend on any axioms +'LexLeanPreservation.Obs.noConfusionType' does not depend on any axioms +'LexLeanPreservation.Obs.noConfusion' does not depend on any axioms +'LexLeanPreservation.Obs.overflow.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Obs.recOn' does not depend on any axioms +'LexLeanPreservation.Obs.stuck.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Obs.value.noConfusion' does not depend on any axioms +'LexLeanPreservation.Obs.value.inj' does not depend on any axioms +'LexLeanPreservation.Obs.value.injEq' depends on axioms: [propext] +'LexLeanPreservation.Obs.value.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.ObsL._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.ObsL._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.ObsL.casesOn' does not depend on any axioms +'LexLeanPreservation.ObsL.ctorElimType' does not depend on any axioms +'LexLeanPreservation.ObsL.ctorIdx' does not depend on any axioms +'LexLeanPreservation.ObsL.ctorElim' does not depend on any axioms +'LexLeanPreservation.ObsL.overflow.elim' does not depend on any axioms +'LexLeanPreservation.ObsL.stuck.elim' does not depend on any axioms +'LexLeanPreservation.ObsL.values.elim' does not depend on any axioms +'LexLeanPreservation.ObsL.noConfusionType' does not depend on any axioms +'LexLeanPreservation.ObsL.noConfusion' does not depend on any axioms +'LexLeanPreservation.ObsL.overflow.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.ObsL.recOn' does not depend on any axioms +'LexLeanPreservation.ObsL.stuck.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.ObsL.values.noConfusion' does not depend on any axioms +'LexLeanPreservation.ObsL.values.inj' does not depend on any axioms +'LexLeanPreservation.ObsL.values.injEq' depends on axioms: [propext] +'LexLeanPreservation.ObsL.values.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rel' does not depend on any axioms +'LexLeanPreservation.Rel.eq_1' does not depend on any axioms +'LexLeanPreservation.RelL' does not depend on any axioms +'LexLeanPreservation.RelL.eq_1' does not depend on any axioms +'LexLeanPreservation.RunConv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.addSteps_ne' does not depend on any axioms +'LexLeanPreservation.chargeResult_ne' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.stable.match_1_16' does not depend on any axioms +'LexLeanPreservation.stable.match_1_18' does not depend on any axioms +'LexLeanPreservation.stable.match_1_20' does not depend on any axioms +'LexLeanPreservation.stable.match_1_22' does not depend on any axioms +'LexLeanPreservation.stable.match_1_24' does not depend on any axioms +'LexLeanPreservation.stable.match_1_26' does not depend on any axioms +'LexLeanTarget.TargetSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.stable' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.evalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.obs_ne' does not depend on any axioms +'LexLeanPreservation.convA_at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.eval_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.obs_addSteps' does not depend on any axioms +'LexLeanPreservation.convA_hit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.convA_miss' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.evalList_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.obsL_ne' does not depend on any axioms +'LexLeanPreservation.convL_at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.convL_cons._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.convL_cons._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.convL_cons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.convL_nil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_apply._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_apply._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_apply._proof_1_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_apply' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_build' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_call._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_call._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_call' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_closure' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_cond._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_cond._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_cond' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_field' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_first' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_let._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_let._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_let' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_match._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_match._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_match' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_matchV' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.obs_chargeResult' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_prim' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_second' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_value' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_var' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.funRel_intro' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.obs.eq_1' does not depend on any axioms +'LexLeanPreservation.obs.eq_2' does not depend on any axioms +'LexLeanPreservation.obs.eq_3' does not depend on any axioms +'LexLeanPreservation.obs.eq_4' does not depend on any axioms +'LexLeanPreservation.obsL.eq_1' does not depend on any axioms +'LexLeanPreservation.obsL.eq_2' does not depend on any axioms +'LexLeanPreservation.obsL.eq_3' does not depend on any axioms +'LexLeanPreservation.obsL.eq_4' does not depend on any axioms +'LexLeanPreservation.run_of_funRel' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.run.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.ListEnc' does not depend on any axioms +'LexLeanPreservation.ListEnc._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.ListEnc._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.ListEnc.casesOn' does not depend on any axioms +'LexLeanPreservation.ListEnc.ctorIdx' does not depend on any axioms +'LexLeanPreservation.ListEnc.elem' does not depend on any axioms +'LexLeanPreservation.ListEnc.items' does not depend on any axioms +'LexLeanPreservation.ListEnc.enc' does not depend on any axioms +'LexLeanPreservation.ListEnc.items_cons' does not depend on any axioms +'LexLeanPreservation.ListEnc.items_eq.match_1_1' does not depend on any axioms +'LexLeanPreservation.ListEnc.items_nil' does not depend on any axioms +'LexLeanPreservation.ListEnc.items_eq._f' does not depend on any axioms +'LexLeanPreservation.ListEnc.items_eq' does not depend on any axioms +'LexLeanPreservation.ListEnc.mk._flat_ctor' does not depend on any axioms +'LexLeanPreservation.ListEnc.noConfusionType' does not depend on any axioms +'LexLeanPreservation.ListEnc.noConfusion' does not depend on any axioms +'LexLeanPreservation.ListEnc.mk.noConfusion' does not depend on any axioms +'LexLeanPreservation.ListEnc.mk.inj' does not depend on any axioms +'LexLeanPreservation.ListEnc.mk.injEq' depends on axioms: [propext] +'LexLeanPreservation.ListEnc.mk.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.ListEnc.recOn' does not depend on any axioms +'LexLeanPreservation.OptEnc' does not depend on any axioms +'LexLeanPreservation.OptEnc._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.OptEnc._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.OptEnc.casesOn' does not depend on any axioms +'LexLeanPreservation.OptEnc.ctorIdx' does not depend on any axioms +'LexLeanPreservation.OptEnc.elem' does not depend on any axioms +'LexLeanPreservation.OptEnc.enc' does not depend on any axioms +'LexLeanPreservation.OptEnc.enc_none' does not depend on any axioms +'LexLeanPreservation.OptEnc.enc_some' does not depend on any axioms +'LexLeanPreservation.encOption.match_1' does not depend on any axioms +'LexLeanPreservation.encOption' does not depend on any axioms +'LexLeanPreservation.OptEnc.enc_map' does not depend on any axioms +'LexLeanPreservation.OptEnc.mk._flat_ctor' does not depend on any axioms +'LexLeanPreservation.OptEnc.noConfusionType' does not depend on any axioms +'LexLeanPreservation.OptEnc.noConfusion' does not depend on any axioms +'LexLeanPreservation.OptEnc.mk.noConfusion' does not depend on any axioms +'LexLeanPreservation.OptEnc.mk.inj' does not depend on any axioms +'LexLeanPreservation.OptEnc.mk.injEq' depends on axioms: [propext] +'LexLeanPreservation.OptEnc.mk.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.OptEnc.recOn' does not depend on any axioms +'LexLeanPreservation.construct_adt' does not depend on any axioms +'LexLeanPreservation.construct_cons' does not depend on any axioms +'LexLeanPreservation.construct_error' does not depend on any axioms +'LexLeanPreservation.construct_false' does not depend on any axioms +'LexLeanPreservation.construct_nil' does not depend on any axioms +'LexLeanPreservation.construct_none' does not depend on any axioms +'LexLeanPreservation.construct_ok' does not depend on any axioms +'LexLeanPreservation.construct_pair' does not depend on any axioms +'LexLeanPreservation.construct_some' does not depend on any axioms +'LexLeanPreservation.construct_succ' does not depend on any axioms +'LexLeanPreservation.construct_true' does not depend on any axioms +'LexLeanPreservation.construct_unit' does not depend on any axioms +'LexLeanPreservation.construct_zero' does not depend on any axioms +'LexLeanPreservation.encExcept.match_1' does not depend on any axioms +'LexLeanPreservation.encExcept' does not depend on any axioms +'LexLeanPreservation.encList' does not depend on any axioms +'LexLeanPreservation.encOrdering.match_1' does not depend on any axioms +'LexLeanPreservation.encOrdering' does not depend on any axioms +'LexLeanPreservation.encPair' does not depend on any axioms +'LexLeanPreservation.encUnit' does not depend on any axioms +'LexLeanPreservation.listEnc._proof_1' does not depend on any axioms +'LexLeanPreservation.listEnc._proof_2' does not depend on any axioms +'LexLeanPreservation.listEnc' does not depend on any axioms +'LexLeanPreservation.optEnc._proof_1' does not depend on any axioms +'LexLeanPreservation.optEnc._proof_2' does not depend on any axioms +'LexLeanPreservation.optEnc' does not depend on any axioms +'LexLeanPreservation.bytes_empty' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.bytes_one' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.bytes_zero' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.encOrdering.eq_1' does not depend on any axioms +'LexLeanPreservation.encOrdering.eq_2' does not depend on any axioms +'LexLeanPreservation.encOrdering.eq_3' does not depend on any axioms +'LexLeanPreservation.fromOrdering_encOrdering' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.fromStrings_map.match_1_1' does not depend on any axioms +'LexLeanPreservation.fromStrings_map._f' does not depend on any axioms +'LexLeanPreservation.fromStrings_map' does not depend on any axioms +'LexLeanPreservation.intFits' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.listIndex_map.match_1_1' does not depend on any axioms +'LexLeanPreservation.listIndex_map._f' does not depend on any axioms +'LexLeanPreservation.listIndex_map' does not depend on any axioms +'LexLeanPreservation.listIndex_unique.match_1_1' does not depend on any axioms +'LexLeanPreservation.listIndex_unique._f' does not depend on any axioms +'LexLeanPreservation.listIndex_unique' does not depend on any axioms +'LexLeanPreservation.obs_intResult' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.obs_natResult' does not depend on any axioms +'LexLeanPreservation.prim_append_bytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_append_list' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_boolNot' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_compareBytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_bool' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_bytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_nat' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_ordering' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_string' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_index_bytes.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_index_bytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_index_list.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_index_list' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_intMul' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_intNeg' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_intQuot' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_intRem' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_intSub' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_join.match_1_1' does not depend on any axioms +'LexLeanPreservation.toStrings_map.match_1_1' does not depend on any axioms +'LexLeanPreservation.toStrings_map.match_1_3' does not depend on any axioms +'LexLeanPreservation.toStrings_map._f' does not depend on any axioms +'LexLeanPreservation.toStrings_map' does not depend on any axioms +'LexLeanPreservation.prim_join' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_length_bytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_length_list' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_length_string' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natAdd' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natEq' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natLe' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natLt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natMul' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natQuot' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natRem' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_natSub' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_slice_bytes.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_slice_bytes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_slice_list.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_slice_list' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_splitExact.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_splitExact' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_utf8Decode.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_utf8Decode' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_utf8Encode' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanRuntime.compareBytes.eq_1' depends on axioms: [propext] +'LexLeanRuntime.equal.eq_1' does not depend on any axioms +'LexLeanRuntime.length.eq_1' does not depend on any axioms +'LexLeanRuntime.slice.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.fromOrdering.eq_1' depends on axioms: [propext] +'LexLeanPreservation.checkedMultiplyWith.match_1' does not depend on any axioms +'LexLeanPreservation.checkedMultiplyWith' does not depend on any axioms +'LexLeanPreservation.checkedQuotientWith' does not depend on any axioms +'LexLeanPreservation.decimalFits.match_1' does not depend on any axioms +'LexLeanPreservation.decimalFits' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.divideStep' does not depend on any axioms +'LexLeanPreservation.divide_unique.match_1_1' does not depend on any axioms +'LexLeanPreservation.divide_unique._f' does not depend on any axioms +'LexLeanPreservation.divide_unique' does not depend on any axioms +'LexLeanPreservation.multiplyStep' does not depend on any axioms +'LexLeanPreservation.multiply_unique.match_1_1' does not depend on any axioms +'LexLeanPreservation.multiply_unique._f' does not depend on any axioms +'LexLeanPreservation.multiply_unique' does not depend on any axioms +'LexLeanPreservation.prim_bitAnd_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitAnd_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitNot_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitOr_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_bitXor_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedAdd_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedAdd_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_i64.match_1_2' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedMul_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedMul_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedNeg_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedNeg_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedNeg_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedNeg_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedNeg_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedNeg_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedNeg_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedNeg_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedQuot_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedQuot_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_checkedSub_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_checkedSub_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i16_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i16_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i32_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i32_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i64_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i64_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_i8_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_i8_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_int_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_int_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u16_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u16_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u32_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u32_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u64_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u64_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_convert_u8_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_convert_u8_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_equal_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_formatDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_int.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_int' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_parseDecimal_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_parseDecimal_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftLeft_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftLeft_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_i16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_i32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_i64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_i8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_u16.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_u32.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_u64.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.prim_shiftRight_u8.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_shiftRight_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.ordOf.match_1' does not depend on any axioms +'LexLeanPreservation.ordOf' does not depend on any axioms +'LexLeanPreservation.KeySpec' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.KeySpec.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.KeySpec.mk._flat_ctor' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.KeySpec.recOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.KeySpec.spec' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.compareCodes_eq.match_1_1' does not depend on any axioms +'LexLeanPreservation.compareCodes_eq._f' depends on axioms: [propext] +'LexLeanPreservation.compareCodes_eq' depends on axioms: [propext] +'LexLeanPreservation.compareCodes_swap.match_1_1' does not depend on any axioms +'LexLeanPreservation.compareCodes_swap._f' depends on axioms: [propext] +'LexLeanPreservation.compareCodes_swap' depends on axioms: [propext] +'LexLeanPreservation.lessThanE' does not depend on any axioms +'LexLeanPreservation.prim_compare_key.match_1_1' does not depend on any axioms +'LexLeanPreservation.prim_compare_key' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_lessThan' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.orderOf_insert' does not depend on any axioms +'LexLeanTarget.TargetSemantics.orderBool.eq_1' depends on axioms: [propext] +'LexLeanPreservation.keySpec_bool' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderI16.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_i16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderI32.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_i32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderI64.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_i64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderI8.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_i8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderInt.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_int' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderNat.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_nat' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.keySpec_pair' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderString.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.keySpec_string' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderU16.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_u16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderU32.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_u32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderU64.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_u64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.orderU8.eq_1' does not depend on any axioms +'LexLeanPreservation.keySpec_u8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanCollections.compareCodes._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanCollections.compareCodes.eq_1' depends on axioms: [propext] +'LexLeanCollections.compareCodes.eq_2' depends on axioms: [propext] +'LexLeanCollections.compareCodes.eq_3' depends on axioms: [propext] +'LexLeanCollections.compareCodes.eq_4' depends on axioms: [propext] +'LexLeanCollections.compareCodes.eq_def' depends on axioms: [propext] +'LexLeanCollections.insertEntry.eq_1' does not depend on any axioms +'LexLeanCollections.insertEntry.eq_2' does not depend on any axioms +'LexLeanCollections.insertEntry.eq_def' does not depend on any axioms +'LexLeanTarget.TargetSemantics.compareValue.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.compareValue.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Conv.bool_eq' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Conv.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.FunRel.fits_eq' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.ListEnc.enc.eq_1' does not depend on any axioms +'LexLeanPreservation.ListEnc.enc_cons' does not depend on any axioms +'LexLeanPreservation.ListEnc.enc_nil' does not depend on any axioms +'LexLeanPreservation.LookOps' does not depend on any axioms +'LexLeanPreservation.LookOps.casesOn' does not depend on any axioms +'LexLeanPreservation.LookOps.l0' does not depend on any axioms +'LexLeanPreservation.LookOps.leq' does not depend on any axioms +'LexLeanPreservation.LookOps.lgt' does not depend on any axioms +'LexLeanPreservation.LookOps.llt' does not depend on any axioms +'LexLeanPreservation.LookOps.mk._flat_ctor' does not depend on any axioms +'LexLeanPreservation.LookOps.recOn' does not depend on any axioms +'LexLeanPreservation.SetOps' does not depend on any axioms +'LexLeanPreservation.SetOps.c0' does not depend on any axioms +'LexLeanPreservation.SetOps.casesOn' does not depend on any axioms +'LexLeanPreservation.SetOps.ceq' does not depend on any axioms +'LexLeanPreservation.SetOps.cgt' does not depend on any axioms +'LexLeanPreservation.SetOps.clt' does not depend on any axioms +'LexLeanPreservation.SetOps.i0' does not depend on any axioms +'LexLeanPreservation.SetOps.ieq' does not depend on any axioms +'LexLeanPreservation.SetOps.igt' does not depend on any axioms +'LexLeanPreservation.SetOps.ilt' does not depend on any axioms +'LexLeanPreservation.SetOps.mk._flat_ctor' does not depend on any axioms +'LexLeanPreservation.SetOps.r0' does not depend on any axioms +'LexLeanPreservation.SetOps.recOn' does not depend on any axioms +'LexLeanPreservation.SetOps.req' does not depend on any axioms +'LexLeanPreservation.SetOps.rgt' does not depend on any axioms +'LexLeanPreservation.SetOps.rlt' does not depend on any axioms +'LexLeanPreservation.TopoOps' does not depend on any axioms +'LexLeanPreservation.TopoOps.casesOn' does not depend on any axioms +'LexLeanPreservation.TopoOps.mk._flat_ctor' does not depend on any axioms +'LexLeanPreservation.TopoOps.recOn' does not depend on any axioms +'LexLeanPreservation.TopoOps.s_next' does not depend on any axioms +'LexLeanPreservation.TopoOps.s_nil' does not depend on any axioms +'LexLeanPreservation.TopoOps.s_stuck' does not depend on any axioms +'LexLeanPreservation.TopoOps.z_cons' does not depend on any axioms +'LexLeanPreservation.TopoOps.z_nil' does not depend on any axioms +'LexLeanPreservation.Tpl.boolE' does not depend on any axioms +'LexLeanPreservation.Tpl.byOrder' does not depend on any axioms +'LexLeanPreservation.Tpl.cns' does not depend on any axioms +'LexLeanPreservation.Tpl.fn' does not depend on any axioms +'LexLeanPreservation.Tpl.lst' does not depend on any axioms +'LexLeanPreservation.Tpl.v' does not depend on any axioms +'LexLeanPreservation.Tpl.graphInnerFn' does not depend on any axioms +'LexLeanPreservation.Tpl.pr' does not depend on any axioms +'LexLeanPreservation.Tpl.graphNodesFn' does not depend on any axioms +'LexLeanPreservation.Tpl.natOne' does not depend on any axioms +'LexLeanPreservation.Tpl.nl' does not depend on any axioms +'LexLeanPreservation.Tpl.graphReachableFn' does not depend on any axioms +'LexLeanPreservation.Tpl.graphSuccessorsFn' does not depend on any axioms +'LexLeanPreservation.Tpl.graphTopologicalFn' does not depend on any axioms +'LexLeanPreservation.Tpl.iterateFn' does not depend on any axioms +'LexLeanPreservation.Tpl.iterateUntilFn' does not depend on any axioms +'LexLeanPreservation.Tpl.listFoldFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapContainsFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapFoldFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapInsertFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapLookupFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapProjectFn' does not depend on any axioms +'LexLeanPreservation.Tpl.mapRemoveFn' does not depend on any axioms +'LexLeanPreservation.Tpl.reachFrontierFn' does not depend on any axioms +'LexLeanPreservation.Tpl.reachIntoFn' does not depend on any axioms +'LexLeanPreservation.Tpl.reachRoundsFn' does not depend on any axioms +'LexLeanPreservation.Tpl.reverseFn' does not depend on any axioms +'LexLeanPreservation.Tpl.setContainsFn' does not depend on any axioms +'LexLeanPreservation.Tpl.setFilterFn' does not depend on any axioms +'LexLeanPreservation.Tpl.setInsertFn' does not depend on any axioms +'LexLeanPreservation.Tpl.setRemoveFn' does not depend on any axioms +'LexLeanPreservation.Tpl.setUnionFn' does not depend on any axioms +'LexLeanPreservation.Tpl.topoFinished' does not depend on any axioms +'LexLeanPreservation.Tpl.topoReadyFn' does not depend on any axioms +'LexLeanPreservation.Tpl.topoRoundsFn' does not depend on any axioms +'LexLeanPreservation.Tpl.topoUnreachedFn' does not depend on any axioms +'LexLeanPreservation.blt_succ_fits._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.blt_succ_fits' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.conv_cond_false' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.conv_cond_true' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.enc_elem' does not depend on any axioms +'LexLeanPreservation.enc_entry' does not depend on any axioms +'LexLeanPreservation.foldFits.match_1' does not depend on any axioms +'LexLeanPreservation.foldFits._f' does not depend on any axioms +'LexLeanPreservation.foldFits' does not depend on any axioms +'LexLeanPreservation.foldFits._sunfold' does not depend on any axioms +'LexLeanPreservation.foldFits._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.foldFits.eq_1' does not depend on any axioms +'LexLeanPreservation.foldFits.eq_2' does not depend on any axioms +'LexLeanPreservation.foldFits.eq_def' does not depend on any axioms +'LexLeanPreservation.graphFits' does not depend on any axioms +'LexLeanPreservation.graphFits.eq_1' does not depend on any axioms +'LexLeanPreservation.iterateFits.match_1' does not depend on any axioms +'LexLeanPreservation.iterateFits._f' does not depend on any axioms +'LexLeanPreservation.iterateFits' does not depend on any axioms +'LexLeanPreservation.iterateFits._sunfold' does not depend on any axioms +'LexLeanPreservation.iterateFits._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.iterateFits.eq_1' does not depend on any axioms +'LexLeanPreservation.iterateFits.eq_2' does not depend on any axioms +'LexLeanPreservation.iterateFits.eq_def' does not depend on any axioms +'LexLeanPreservation.length_eq' does not depend on any axioms +'LexLeanPreservation.prim_compare_at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.reachNext' does not depend on any axioms +'LexLeanPreservation.tpl_graphInner.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setInsert.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setInsert' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphInner._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphInner' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphNodes.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_graphNodes._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphNodes' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapLookup.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapLookup._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapLookup' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphSuccessors' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachFrontier.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_reachInto.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setContains.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setContains._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setContains' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachInto._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachInto' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachFrontier._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachFrontier' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachRounds.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setUnion.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setUnion._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setUnion' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reachRounds' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphReachable' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reverse.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_reverse._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_reverse' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setRemove.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setRemove' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoReady.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_topoUnreached.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_topoUnreached._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoUnreached' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoReady._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoReady' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoRounds.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_topoRounds._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_topoRounds' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_graphTopological' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_iterate.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_iterate._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_iterate' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_iterateUntil.match_1_1' does not depend on any axioms +'LexLeanPreservation.untilFits.match_1' does not depend on any axioms +'LexLeanPreservation.untilFits._f' does not depend on any axioms +'LexLeanPreservation.untilFits' does not depend on any axioms +'LexLeanPreservation.tpl_iterateUntil._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_iterateUntil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_listFold.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_listFold._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_listFold' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapContains' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapFold.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapFold._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapFold' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapInsert.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapInsert._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapInsert' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapKeys.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapKeys._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapKeys' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapRemove.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapRemove._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapRemove' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapValues.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_mapValues._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_mapValues' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setDifference.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setDifference._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setDifference' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setIntersection.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_setIntersection._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_setIntersection' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.untilFits._sunfold' does not depend on any axioms +'LexLeanPreservation.untilFits._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.untilFits.eq_1' does not depend on any axioms +'LexLeanPreservation.untilFits.eq_2' does not depend on any axioms +'LexLeanPreservation.untilFits.eq_def' does not depend on any axioms +'LexLeanPreservation.validExcept.match_1' does not depend on any axioms +'LexLeanPreservation.InvExcept' does not depend on any axioms +'LexLeanPreservation.InvList' does not depend on any axioms +'LexLeanPreservation.InvList.eq_1' does not depend on any axioms +'LexLeanPreservation.StrictAsc.match_1' does not depend on any axioms +'LexLeanPreservation.StrictAsc._f' does not depend on any axioms +'LexLeanPreservation.StrictAsc' does not depend on any axioms +'LexLeanPreservation.InvMap' does not depend on any axioms +'LexLeanPreservation.validOption.match_1' does not depend on any axioms +'LexLeanPreservation.InvOption' does not depend on any axioms +'LexLeanPreservation.InvOption.eq_1' does not depend on any axioms +'LexLeanPreservation.InvOption.eq_2' does not depend on any axioms +'LexLeanPreservation.InvPair' does not depend on any axioms +'LexLeanPreservation.InvSet' does not depend on any axioms +'LexLeanPreservation.StrictAsc._sunfold' does not depend on any axioms +'LexLeanPreservation.StrictAsc._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.StrictAsc.eq_1' does not depend on any axioms +'LexLeanPreservation.StrictAsc.eq_2' does not depend on any axioms +'LexLeanPreservation.StrictAsc.eq_3' does not depend on any axioms +'LexLeanPreservation.StrictAsc.eq_def' does not depend on any axioms +'LexLeanPreservation.Tpl.validListFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validMapFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validOptionFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validPairFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validResultFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validSetFn' does not depend on any axioms +'LexLeanPreservation.Tpl.validTrueFn' does not depend on any axioms +'LexLeanPreservation.ascMap.match_1' does not depend on any axioms +'LexLeanPreservation.lessB.match_1' does not depend on any axioms +'LexLeanPreservation.lessB' does not depend on any axioms +'LexLeanPreservation.ascMap._f' does not depend on any axioms +'LexLeanPreservation.ascMap' does not depend on any axioms +'LexLeanPreservation.ascMap._sunfold' does not depend on any axioms +'LexLeanPreservation.ascMap._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.ascMap.eq_1' does not depend on any axioms +'LexLeanPreservation.ascMap.eq_2' does not depend on any axioms +'LexLeanPreservation.ascMap.eq_3' does not depend on any axioms +'LexLeanPreservation.ascMap.eq_def' does not depend on any axioms +'LexLeanPreservation.ascMap_iff.match_1_1' does not depend on any axioms +'LexLeanPreservation.lessB_iff' depends on axioms: [propext] +'LexLeanPreservation.ascMap_iff._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.ascMap_iff' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.ascMap_inv' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.ascSet._f' does not depend on any axioms +'LexLeanPreservation.ascSet' does not depend on any axioms +'LexLeanPreservation.ascSet._sunfold' does not depend on any axioms +'LexLeanPreservation.ascSet._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.ascSet.eq_1' does not depend on any axioms +'LexLeanPreservation.ascSet.eq_2' does not depend on any axioms +'LexLeanPreservation.ascSet.eq_3' does not depend on any axioms +'LexLeanPreservation.ascSet.eq_def' does not depend on any axioms +'LexLeanPreservation.ascSet_iff.match_1_1' does not depend on any axioms +'LexLeanPreservation.ascSet_iff._f' depends on axioms: [propext] +'LexLeanPreservation.ascSet_iff' depends on axioms: [propext] +'LexLeanPreservation.ascSet_inv' depends on axioms: [propext] +'LexLeanPreservation.condAnd_iff' depends on axioms: [propext] +'LexLeanPreservation.invList_eqs.match_1_1' does not depend on any axioms +'LexLeanPreservation.invList_eqs._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.invList_eqs' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.lessB.eq_1' does not depend on any axioms +'LexLeanPreservation.lessB_eq' depends on axioms: [propext] +'LexLeanPreservation.lessB_gt' depends on axioms: [propext] +'LexLeanPreservation.lessB_lt' depends on axioms: [propext] +'LexLeanPreservation.someObs.match_1' does not depend on any axioms +'LexLeanPreservation.someObs' does not depend on any axioms +'LexLeanPreservation.tpl_validList.match_1_1' does not depend on any axioms +'LexLeanPreservation.validList.match_1' does not depend on any axioms +'LexLeanPreservation.validList._f' does not depend on any axioms +'LexLeanPreservation.validList' does not depend on any axioms +'LexLeanPreservation.tpl_validList' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validMap.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_validMap._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validMap' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validOption.match_1_1' does not depend on any axioms +'LexLeanPreservation.validOption' does not depend on any axioms +'LexLeanPreservation.tpl_validOption' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validPair.match_1_1' does not depend on any axioms +'LexLeanPreservation.validPair' does not depend on any axioms +'LexLeanPreservation.tpl_validPair' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validResult.match_1_1' does not depend on any axioms +'LexLeanPreservation.validExcept' does not depend on any axioms +'LexLeanPreservation.tpl_validResult' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validSet.match_1_1' does not depend on any axioms +'LexLeanPreservation.tpl_validSet._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validSet' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.tpl_validTrue' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.trueIff' does not depend on any axioms +'LexLeanPreservation.validExcept_inv.match_1_1' does not depend on any axioms +'LexLeanPreservation.validExcept_inv' does not depend on any axioms +'LexLeanPreservation.validList._sunfold' does not depend on any axioms +'LexLeanPreservation.validList._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.validList.eq_1' does not depend on any axioms +'LexLeanPreservation.validList.eq_2' does not depend on any axioms +'LexLeanPreservation.validList.eq_def' does not depend on any axioms +'LexLeanPreservation.validList_iff.match_1_1' does not depend on any axioms +'LexLeanPreservation.validList_iff._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.validList_iff' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.validList_inv' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.validOption.eq_1' does not depend on any axioms +'LexLeanPreservation.validOption.eq_2' does not depend on any axioms +'LexLeanPreservation.validOption_inv.match_1_1' does not depend on any axioms +'LexLeanPreservation.validOption_inv' depends on axioms: [propext] +'LexLeanPreservation.validPair_inv' depends on axioms: [propext] +'LexLeanPreservation.validTrue_inv' does not depend on any axioms +'LexLeanPreservation.Rust.Ctx' does not depend on any axioms +'LexLeanPreservation.Rust.Flags' does not depend on any axioms +'LexLeanPreservation.Rust.RCrate' does not depend on any axioms +'LexLeanPreservation.Rust.RIdent' does not depend on any axioms +'LexLeanPreservation.Rust.WT._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.adtFields' depends on axioms: [propext] +'LexLeanTarget.TargetSyntax.IntKind.ofNat' does not depend on any axioms +'LexLeanTarget.TargetSyntax.IntKind.ofNat_ctorIdx' does not depend on any axioms +'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_1' does not depend on any axioms +'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation._proof_2' does not depend on any axioms +'LexLeanPreservation.Rust.instDecidableEqIntKind_lexLeanPreservation' does not depend on any axioms +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq' depends on axioms: [propext] +'LexLeanPreservation.Rust.flagOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.fnIdent' does not depend on any axioms +'LexLeanPreservation.Rust.fnFallible' does not depend on any axioms +'LexLeanPreservation.Rust.inert.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.inert._f' does not depend on any axioms +'LexLeanPreservation.Rust.inert' does not depend on any axioms +'LexLeanPreservation.Rust.WT._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.WTAll._f' does not depend on any axioms +'LexLeanPreservation.Rust.WTL.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctxLookup.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup._f' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup' does not depend on any axioms +'LexLeanPreservation.Rust.local_' does not depend on any axioms +'LexLeanPreservation.Rust.EnvRel' depends on axioms: [propext] +'LexLeanPreservation.Rust.ROut' does not depend on any axioms +'LexLeanPreservation.Rust.Halt' does not depend on any axioms +'LexLeanPreservation.Rust.REnv' does not depend on any axioms +'LexLeanPreservation.Rust.RExpr' does not depend on any axioms +'LexLeanPreservation.Rust.RC' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RLet' does not depend on any axioms +'LexLeanPreservation.Rust.LetsOK' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.append' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.below' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsOK.recOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.append_left' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.append_right' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.below' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.below.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.brecOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.casesOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.LetsRaise.recOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RBlock' does not depend on any axioms +'LexLeanPreservation.Rust.dispatched_ne' does not depend on any axioms +'LexLeanPreservation.Rust.finished_ne' does not depend on any axioms +'LexLeanPreservation.Rust.returned_ne' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_24' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_26' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_28' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_30' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_32' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_34' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_36' does not depend on any axioms +'LexLeanPreservation.Rust.stable.match_1_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.eval.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalArms.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalBlock.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalBlock.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalList.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.invoke.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.stable' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.reval_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RC.at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCB' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RC.block' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCA' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.revalBlock_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCB.at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCI' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.invoke_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCI.at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCL' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.revalList_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RCL.at' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.WTAll' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.block_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.block_of_raise' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.ctxLookup._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup_slot._simp_1_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.slotFree' does not depend on any axioms +'LexLeanPreservation.Rust.ctxLookup_slot' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rlookup_cons_other' depends on axioms: [propext] +'LexLeanPreservation.Rust.sameIdent_self' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rlookup_cons_self' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sameIdent_local' depends on axioms: [propext] +'LexLeanPreservation.Rust.envRel_bind' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.envRel_extra' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.envRel_ghost' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sameIdent_kind' depends on axioms: [propext] +'LexLeanPreservation.Rust.envRel_temp' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL' depends on axioms: [propext] +'LexLeanPreservation.Rust.listIndex_eq.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.listIndex_eq._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.listIndex_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.index_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.inert._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.inert._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_nil.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_nil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_raise_head.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rcl_raise_head.match_1_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.rcl_raise_head' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_raise_tail' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.revalArms_le' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.slotFree.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.tyBeq._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._sunfold' depends on axioms: [propext] +'LexLeanTarget.RustSemantics.eval.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.eval.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalArms.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalArms.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalArms.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalBlock.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalBlock.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalList.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalList.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.evalList.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.invoke.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.invoke.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.kindNumber.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.kindNumber.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.lookup.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.lookup.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.lookup.eq_def' does not depend on any axioms +'LexLeanTarget.RustSemantics.sameIdent.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.sameIdent.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.sameIdent.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.sameIdent.eq_4' does not depend on any axioms +'LexLeanTarget.TargetSemantics.lookup.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.lookup.eq_2' does not depend on any axioms +'LexLeanTarget.TargetSemantics.lookup.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.Kind' does not depend on any axioms +'LexLeanPreservation.Rust.Jd' does not depend on any axioms +'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isTemp.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isTemp' depends on axioms: [propext] +'LexLeanPreservation.Rust.letsBind.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds._f' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds._f' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind._f' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind' does not depend on any axioms +'LexLeanPreservation.Rust.tempFresh' does not depend on any axioms +'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.foldN.match_3' does not depend on any axioms +'LexLeanPreservation.Rust.flatB._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.flatB.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.flatB' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep.match_7' does not depend on any axioms +'LexLeanPreservation.Rust.foldStep' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldB' depends on axioms: [propext] +'LexLeanPreservation.Rust.fieldPats.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats._f' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats' does not depend on any axioms +'LexLeanPreservation.Rust.okBlock' does not depend on any axioms +'LexLeanPreservation.Rust.partRead._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead' depends on axioms: [propext] +'LexLeanPreservation.Rust.Kind.casesOn' does not depend on any axioms +'LexLeanPreservation.Rust.elseCtx.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.elseCtx' does not depend on any axioms +'LexLeanPreservation.Rust.elseLets.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.elseLets' does not depend on any axioms +'LexLeanPreservation.Rust.heldOK.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.heldOK' does not depend on any axioms +'LexLeanPreservation.Rust.negateR._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.negateR._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.negateR.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.negateR' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.directPat.match_3' does not depend on any axioms +'LexLeanPreservation.Rust.directPat.match_5' does not depend on any axioms +'LexLeanPreservation.Rust.directPat.match_7' does not depend on any axioms +'LexLeanPreservation.Rust.directPat.match_9' does not depend on any axioms +'LexLeanPreservation.Rust.identLocal.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.identBoxed' does not depend on any axioms +'LexLeanPreservation.Rust.identLocal' does not depend on any axioms +'LexLeanPreservation.Rust.isWild._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isWild.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isWild' depends on axioms: [propext] +'LexLeanPreservation.Rust.loadOf.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.unboxOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.unboxOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.loadOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.slotOK.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.directPat._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocal' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields' depends on axioms: [propext] +'LexLeanPreservation.Rust.armPat' depends on axioms: [propext] +'LexLeanPreservation.Rust.armShape.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.armShape' does not depend on any axioms +'LexLeanPreservation.Rust.otherArms.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq' depends on axioms: [propext] +'LexLeanPreservation.Rust.otherArms' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.noClosure.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.noClosure.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.noClosure' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh' depends on axioms: [propext] +'LexLeanPreservation.Rust.covered' depends on axioms: [propext] +'LexLeanPreservation.Rust.scrut' does not depend on any axioms +'LexLeanPreservation.Rust.validU.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.validU' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms' depends on axioms: [propext] +'LexLeanPreservation.Rust.slotOK' does not depend on any axioms +'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctorOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctorOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.identsDistinct.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.identsDistinct._f' does not depend on any axioms +'LexLeanPreservation.Rust.identsDistinct' does not depend on any axioms +'LexLeanPreservation.Rust.litOf._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.litOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.litOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg.match_6' does not depend on any axioms +'LexLeanPreservation.Rust.rebuildArg.match_8' does not depend on any axioms +'LexLeanPreservation.Rust.rebuildArg' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArgs._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildTail.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail.match_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildsArm.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.rebuildsArm' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.itemOK.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.itemOK' does not depend on any axioms +'LexLeanPreservation.Rust.itemTyped.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.itemTyped.match_3' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf' does not depend on any axioms +'LexLeanPreservation.Rust.itemTyped' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem' depends on axioms: [propext] +'LexLeanPreservation.Rust.elemOf.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.elemOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.match_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.match_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.match_9' does not depend on any axioms +'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isFixed.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isFixed' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped' depends on axioms: [propext] +'LexLeanPreservation.Rust.primTyped' depends on axioms: [propext] +'LexLeanPreservation.Rust.litValue._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.litValue.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.litValue._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.litValues._f' does not depend on any axioms +'LexLeanPreservation.Rust.litValue' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.typedLitAll._f' does not depend on any axioms +'LexLeanPreservation.Rust.typedLits.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit' depends on axioms: [propext] +'LexLeanPreservation.Rust.Corr' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Corr.below' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Corr.below.casesOn' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Corr.brecOn' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Corr.casesOn' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Corr.recOn' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.FunOK' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.CrateOK' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.Fresh' does not depend on any axioms +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn' depends on axioms: [propext] +'LexLeanPreservation.Rust.FunSem' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.Kind._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.Rust.Kind._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.Rust.Jd._sizeOf_1' does not depend on any axioms +'LexLeanPreservation.Rust.Jd._sizeOf_inst' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.casesOn' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ctorElimType' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ctorIdx' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ctorElim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.b.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.e.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.k.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.l.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.m.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ops.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.noConfusionType' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.b.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.b.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.b.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.b.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.e.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.e.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.e.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.e.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.k.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.k.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.k.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.k.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.l.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.l.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.l.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.l.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.m.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.m.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.m.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.m.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ops.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ops.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.ops.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Jd.ops.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Jd.recOn' does not depend on any axioms +'LexLeanPreservation.Rust.KPre.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.KPre' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.Kind.ctorElimType' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.ctorIdx' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.ctorElim' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.nat.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.noConfusionType' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.nat.noConfusion' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.nat.inj' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.nat.injEq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Kind.nat.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.plain.elim' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.plain.sizeOf_spec' does not depend on any axioms +'LexLeanPreservation.Rust.Kind.recOn' does not depend on any axioms +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesM.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.RealizesM' depends on axioms: [propext] +'LexLeanPreservation.Rust.Sem.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal' depends on axioms: [propext] +'LexLeanPreservation.Rust.Sem' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.WT._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.WT.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTAll.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.fieldPats._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.foldN._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.identsDistinct._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.identsDistinct._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_10' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_11' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_12' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_13' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_14' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_5' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_6' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_7' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_8' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_9' does not depend on any axioms +'LexLeanPreservation.Rust.inert.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.litValues' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue._sunfold' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.litValue._unsafe_rec' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues._sunfold' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.paramCtx._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.patsBinds' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.patLocals._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.patsBinds._sunfold' does not depend on any axioms +'LexLeanPreservation.Rust.rebuildArgs._sunfold' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs._unsafe_rec' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.typedLitAll' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.typedLits._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_of_inert.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.wt_of_inert.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.wt_of_inert._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_of_inert' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_of_inert._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_of_inert' depends on axioms: [propext] +'LexLeanPreservation.Rust.Halt.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.LetsRaise.halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RC.block_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.RC.boxed' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.Realizes.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesF.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesFn.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesL.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesM.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.RealizesM.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.WTL.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_bytes_inv' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_list_inv' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_string_inv' depends on axioms: [propext] +'LexLeanPreservation.Rust.takes_of_typed' depends on axioms: [propext] +'LexLeanPreservation.Rust.allWidth_of.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq_eq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq_eq._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.tysBeq_eq.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq_eq._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq_eq' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.wt_fixed' depends on axioms: [propext] +'LexLeanPreservation.Rust.allWidth_of._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.allWidth_of' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.width_of_typed.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.width_of_typed.match_3' does not depend on any axioms +'LexLeanPreservation.Rust.width_of_typed.match_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.width_of_typed' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.accepts_of_typed' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_apply' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wtl_append.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_append._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_append' depends on axioms: [propext] +'LexLeanPreservation.Rust.apply_result' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.bindPattern_shape.match_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.bindPattern_shape._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.bindPatterns_shape._simp_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindPatterns_shape.match_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPatterns.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPatterns.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.bindPatterns_shape._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.bindPattern_shape' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.bindPatterns_shape' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.boolArms_spec' depends on axioms: [propext] +'LexLeanPreservation.Rust.evalArms_find._proof_1_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find._proof_1_4' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find._proof_1_6' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find._proof_1_7' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.evalArms_find' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.boolArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.boxWith.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxWith.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_11.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.elemOf._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.buildShape.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.build_sound.match_1_100' depends on axioms: [propext] +'LexLeanPreservation.Rust.build_sound.match_1_102' depends on axioms: [propext] +'LexLeanPreservation.Rust.build_sound.match_1_96' depends on axioms: [propext] +'LexLeanPreservation.Rust.build_sound.match_1_98' depends on axioms: [propext] +'LexLeanPreservation.Rust.build_sound' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_call_function' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.call_result' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.constShape.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.const_sound' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.convert_args.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.convert_args' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rlookup_append_fresh' depends on axioms: [propext] +'LexLeanPreservation.Rust.envRel_fresh' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_not._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.eval_cond.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.eval_cond' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.itemResult.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.eval_match' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.fixedTyped.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_15' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_16' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_17' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_18' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_19' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_20' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_21' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_22' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_23' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_24' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_25' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_26' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_27' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_28' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_29' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_30' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_31' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_32' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_33' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_34' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_35' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_36' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_37' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_38' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_39' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_40' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_41' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_42' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_43' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_44' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_45' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_46' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_47' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_48' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_49' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_50' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_51' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_52' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_53' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_54' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_55' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_56' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_57' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_58' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_59' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_60' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_61' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.fixedTyped.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.flatB._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.flatB.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.flatB.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN_sound.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.split_last.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.split_last._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.split_last' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep_spec' depends on axioms: [propext] +'LexLeanPreservation.Rust.rcb_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_nomatch.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcb_cons_nomatch' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_stop' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_cons_value' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_prefix' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_flat' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_read_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rlookup_cons_same' depends on axioms: [propext] +'LexLeanPreservation.Rust.rcb_fold_last' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_nil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.foldStep_sound' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.foldN_sound._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.foldN_sound' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.foldB_sound' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.foldN.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldN.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_append' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_bind._simp_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_bind' depends on axioms: [propext] +'LexLeanPreservation.Rust.slotFree_cons' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_weaken' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_elseCtx' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_nil' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_temp._simp_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_temp' depends on axioms: [propext] +'LexLeanPreservation.Rust.fromStrings_wt.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.fromStrings_wt._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.fromStrings_wt' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.haltL.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.hasWidth_i16' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_i32' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_i64' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_i8' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_u16' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_u32' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_u64' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.hasWidth_u8' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.heldOK.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.heldOK.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.isFixed._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.isFixed.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isFixed.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.isFixed_eq' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.isSeq._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.isSeq_eq' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.isTemp._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.itemOK.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.itemOperands_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.itemResult' does not depend on any axioms +'LexLeanPreservation.Rust.itemResult.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.itemResult.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.itemResult.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.itemResult.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.kpre_cond' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_pred._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_pred.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.rc_pred' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.kpre_else' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.kpre_then' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_cond' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_of_lets' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_b_rcb' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.k_branch' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_cond_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_isZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_lit_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_negate_halt.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_negate_halt.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.rc_nonZero_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_15' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_17' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_19' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_21' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_23' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_25' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_27' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_29' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_31' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_33' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_35' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_37' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_39' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_41' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_43' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_45' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_47' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_49' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_51' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not.match_1_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_not_inv.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_not_inv.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.rc_not_inv.match_1_5' does not depend on any axioms +'LexLeanPreservation.Rust.rc_not_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_negate_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.k_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_read.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_read' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.kpre_held' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.letsBind.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.letsBind.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.letsOK_nil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.letsOK_shape' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.litValue._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.litValue.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue.eq_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue.eq_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue.eq_4' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue.eq_def' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValue.eq_5' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues.eq_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.litValues.eq_def' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.lit_branch' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.lookup_through._simp_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.lookup_through' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms_spec' depends on axioms: [propext] +'LexLeanPreservation.Rust.natArms_eval' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.obsL_evalList_zero' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.obs_eval_zero' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.oneOf.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf.eq_5' does not depend on any axioms +'LexLeanPreservation.Rust.oneOf_halt' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.param_env.match_1_1' depends on axioms: [propext] +'LexLeanTarget.TargetSemantics.bindAll.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.bindAll.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.param_env._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.param_env' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.patBinds.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_10' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_5' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_6' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_7' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_8' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_9' does not depend on any axioms +'LexLeanPreservation.Rust.patBinds.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.patsBinds.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.primTyped.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rc_apply_halt.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_apply_halt.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.rc_apply_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_call_halt._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rc_call_halt.match_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_call_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_call_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_call_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_call_runtime' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_construct.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_construct' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_construct_halt.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_construct_halt.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_construct_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_isZero.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_isZero' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_lit.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_lit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_litValue._simp_10' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_litValue._simp_9' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_litValue.match_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rc_pair.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_pair' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_litValue._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_litValues.match_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rcl_litValues._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_litValue' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_negate.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_nonZero.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_nonZero' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_negate' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_pair_halt_left' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_pair_halt_right' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed.match_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed.match_1_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed.match_1_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed.match_1_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_succeed' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_widen.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rc_widen' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_widen_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_boxWith.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_boxWith.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_boxWith.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_boxWith.match_1_8' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_11' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_5' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_7' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv.match_1_9' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_cons_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_boxWith._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_boxWith' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_litValues' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_nil_inv' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_single_halt.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_single_halt.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.rcl_single_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_widen_one' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.readOf._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.readOf.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.realizesL_halt' depends on axioms: [propext] +'LexLeanPreservation.Rust.realizesL_haltL' depends on axioms: [propext] +'LexLeanPreservation.Rust.realizes_halt' depends on axioms: [propext] +'LexLeanPreservation.Rust.realizesM_overflow' depends on axioms: [propext] +'LexLeanPreservation.Rust.realizes_oneOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.runItem_eq' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.runItem_succ' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_applyGen.match_1_13' does not depend on any axioms +'LexLeanPreservation.Rust.sem_applyGen.match_1_15' does not depend on any axioms +'LexLeanPreservation.Rust.sem_applyGen.match_1_28' does not depend on any axioms +'LexLeanPreservation.Rust.sem_applyGen.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.sem_applyGen' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_apply' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_applyF' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_bOfE' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_build.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_build.match_1_99' does not depend on any axioms +'LexLeanPreservation.Rust.sem_build' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_buildConst' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_buildPair.match_1_101' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildPair.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildPair.match_1_9' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildPair.match_1_97' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildPair.match_1_99' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildPair' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_buildSucc.match_1_129' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildSucc.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildSucc' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_buildSuccF.match_1_101' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildSuccF.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_buildSuccF' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_callF.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_callF.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.sem_callF' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_callOps.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_callOps.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.sem_callOps' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_closure.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.sem_closure.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_closure.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_closure.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.sem_closure.match_1_8' does not depend on any axioms +'LexLeanPreservation.Rust.wtl_length.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_length._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_length' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_closure' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_cond.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_cond.match_1_11' does not depend on any axioms +'LexLeanPreservation.Rust.sem_cond' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_condId.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_condId' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_eOfB' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_eOfBFold' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_eOfBNil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_fOfB' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_unit' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_fUnit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kHeld' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kLit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kId' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kIf' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kNeg' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_kSame' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_lCons.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.sem_lCons.match_1_17' does not depend on any axioms +'LexLeanPreservation.Rust.sem_lCons.match_1_19' does not depend on any axioms +'LexLeanPreservation.Rust.sem_lCons.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.sem_lCons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_lNil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_letBind.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_letBind.match_1_9' does not depend on any axioms +'LexLeanPreservation.Rust.sem_letBind' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_letWild.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_letWild.match_1_9' does not depend on any axioms +'LexLeanPreservation.Rust.sem_letWild' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchBool._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchHolder.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchHolder.match_1_8' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchHolder' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchBool' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchBoolId._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchBoolId.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchBoolId' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchNat._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchNat' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchUnit._proof_1_386' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchUnit.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchUnit.match_1_387' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchUnit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_opsCons._simp_1_13' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_opsCons.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsCons.match_1_14' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsCons.match_1_16' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsCons.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsCons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_opsNil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_opsOfL' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_opsUnit.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsUnit.match_1_29' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsUnit.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsUnit.match_1_31' does not depend on any axioms +'LexLeanPreservation.Rust.sem_opsUnit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_ops_box.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_ops_box.match_1_3' does not depend on any axioms +'LexLeanPreservation.Rust.sem_ops_box.match_1_5' does not depend on any axioms +'LexLeanPreservation.Rust.sem_ops_box' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_part.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_part.match_1_14' does not depend on any axioms +'LexLeanPreservation.Rust.sem_part.match_1_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPatterns.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_part' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_part._sparseCasesOn_1_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_prim.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_prim.match_1_38' does not depend on any axioms +'LexLeanPreservation.Rust.wtAll_iff.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.wtAll_iff._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.wtAll_iff' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_def' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_append' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_bitwise' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_checked' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_convert' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_decode' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_encode' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_fixedTyped.match_1_67' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_format' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_index' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_join' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_parse' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_shift' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.slice_eq' does not depend on any axioms +'LexLeanPreservation.Rust.wt_slice' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_split' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_unary' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wtl_one.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_one' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_three.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_three' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_two.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_two' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_fixedTyped' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wt_prim' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_prim' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_primF.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primF.match_1_5' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primF.match_1_7' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primF.match_1_9' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primF' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_primWiden.match_1_108' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_110' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_112' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_114' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_116' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_primWiden' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.typedLitAll_wt.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll_wt._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit_wt.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit_wt._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits_wt.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits_wt._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit_wt' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_value' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_var' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_varUnit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_zero' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.shapeOf.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_10' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_11' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_12' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_13' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_14' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_5' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_6' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_7' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_8' does not depend on any axioms +'LexLeanPreservation.Rust.shapeOf.eq_9' does not depend on any axioms +'LexLeanPreservation.Rust.tempFresh.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_13.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_14.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_15' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_11.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLit.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLitAll_wt' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.typedLits_wt' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.tysBeq_eq' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.allWidth.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.allWidth.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.allWidth.eq_def' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_100' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_101' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_102' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_103' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_104' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_105' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_106' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_107' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_108' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_109' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_110' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_111' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_112' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_113' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_114' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_115' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_116' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_117' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_118' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_119' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_120' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_121' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_122' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_123' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_124' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_125' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_126' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_127' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_128' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_129' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_130' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_131' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_132' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_133' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_134' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_135' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_136' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_137' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_138' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_139' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_140' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_141' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_142' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_143' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_144' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_145' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_146' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_147' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_148' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_149' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_150' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_151' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_152' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_153' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_154' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_155' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_156' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_157' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_158' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_159' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_160' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_161' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_162' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_163' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_164' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_165' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_166' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_167' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_168' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_169' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_170' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_171' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_172' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_173' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_174' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_175' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_176' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_177' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_178' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_179' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_180' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_181' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_182' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_183' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_184' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_185' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_186' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_51' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_52' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_53' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_54' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_55' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_56' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_57' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_58' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_59' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_60' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_61' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_62' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_63' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_64' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_65' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_66' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_67' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_68' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_69' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_70' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_71' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_72' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_73' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_74' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_75' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_76' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_77' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_78' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_79' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_80' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_81' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_82' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_83' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_84' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_85' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_86' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_87' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_88' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_89' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_90' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_91' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_92' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_93' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_94' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_95' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_96' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_97' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_98' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_99' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPattern.eq_def' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPatterns.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.bindPatterns.eq_def' does not depend on any axioms +'LexLeanTarget.RustSemantics.dispatched.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.dispatched.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.dispatched.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.dispatched.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.dispatched.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_100' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_101' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_102' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_103' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_104' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_105' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_106' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_107' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_108' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_109' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_110' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_111' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_112' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_113' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_114' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_115' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_116' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_117' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_118' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_119' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_120' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_121' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_122' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_123' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_124' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_125' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_126' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_127' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_128' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_129' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_130' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_131' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_132' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_133' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_134' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_135' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_136' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_137' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_138' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_139' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_140' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_141' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_142' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_143' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_144' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_145' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_146' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_147' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_148' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_149' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_150' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_151' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_152' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_153' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_154' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_155' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_156' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_157' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_158' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_159' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_160' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_161' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_162' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_163' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_164' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_165' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_166' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_167' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_168' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_169' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_170' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_171' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_172' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_173' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_174' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_175' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_176' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_177' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_178' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_179' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_180' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_181' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_182' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_183' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_184' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_51' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_52' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_53' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_54' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_55' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_56' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_57' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_58' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_59' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_60' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_61' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_62' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_63' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_64' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_65' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_66' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_67' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_68' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_69' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_70' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_71' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_72' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_73' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_74' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_75' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_76' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_77' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_78' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_79' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_80' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_81' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_82' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_83' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_84' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_85' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_86' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_87' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_88' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_89' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_90' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_91' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_92' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_93' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_94' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_95' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_96' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_97' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_98' does not depend on any axioms +'LexLeanTarget.RustSemantics.hasWidth.eq_99' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.isBytes.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.isList.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.isString.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemAccepts.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemAccepts.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemFallible.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemHeap.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemOperands.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemPrimitive.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemTakes.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_28' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_29' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_30' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_31' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_32' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_33' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_34' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_35' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_36' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_37' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_38' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_39' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_40' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_41' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_42' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_43' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_44' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_45' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_46' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_47' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_48' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_49' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_50' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.itemWidth.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.literal.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_10' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_11' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_12' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_13' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_14' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_15' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_2' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_3' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_4' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_5' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_6' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_7' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_8' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.literal.eq_9' depends on axioms: [propext, Quot.sound] +'LexLeanTarget.RustSemantics.propagated.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_10' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_11' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_12' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_13' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_14' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_15' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_16' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_17' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_18' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_19' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_20' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_21' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_22' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_23' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_24' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_25' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_26' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_27' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_5' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_6' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_7' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_8' does not depend on any axioms +'LexLeanTarget.RustSemantics.propagated.eq_9' does not depend on any axioms +'LexLeanTarget.RustSemantics.returned.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.bindAll.eq_3' does not depend on any axioms +'LexLeanTarget.TargetSemantics.bindAll.eq_4' does not depend on any axioms +'LexLeanTarget.TargetSemantics.bindAll.eq_def' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_10' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_11' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_12' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_13' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_14' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_15' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_16' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_17' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_18' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_19' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_2' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_20' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_21' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_22' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_23' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_24' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_25' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_26' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_27' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_28' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_29' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_3' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_30' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_31' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_32' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_33' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_34' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_35' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_36' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_37' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_38' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_39' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_4' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_40' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_41' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_42' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_43' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_44' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_45' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_46' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_47' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_48' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_49' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_5' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_50' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_51' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_52' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_53' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_54' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_55' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_56' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_57' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_58' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_59' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_6' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_60' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_61' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_62' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_63' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_64' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_65' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_66' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_67' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_68' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_69' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_7' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_70' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_71' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_72' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_73' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_74' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_75' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_76' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_77' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_78' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_79' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_8' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_80' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_81' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_82' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_83' does not depend on any axioms +'LexLeanTarget.TargetSemantics.construct.eq_9' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_10' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_100' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_101' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_102' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_103' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_104' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_105' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_106' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_107' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_108' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_109' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_11' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_110' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_111' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_112' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_113' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_114' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_115' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_116' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_117' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_118' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_119' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_12' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_120' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_121' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_122' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_123' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_124' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_125' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_126' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_127' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_128' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_129' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_13' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_130' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_131' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_132' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_133' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_134' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_135' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_136' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_137' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_138' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_139' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_14' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_140' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_141' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_142' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_143' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_144' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_145' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_146' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_147' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_148' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_149' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_15' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_150' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_151' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_152' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_153' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_154' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_155' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_156' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_157' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_158' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_159' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_16' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_160' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_161' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_162' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_163' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_164' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_165' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_166' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_167' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_168' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_169' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_17' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_170' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_171' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_172' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_173' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_174' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_175' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_176' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_177' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_178' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_179' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_18' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_180' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_181' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_182' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_183' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_184' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_185' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_186' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_187' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_188' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_189' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_19' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_190' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_191' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_192' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_193' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_194' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_195' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_196' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_197' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_198' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_199' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_2' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_20' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_200' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_201' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_202' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_203' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_204' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_205' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_206' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_207' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_208' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_209' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_21' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_210' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_211' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_212' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_213' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_214' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_215' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_216' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_217' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_218' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_219' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_22' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_220' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_221' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_222' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_223' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_224' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_225' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_226' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_227' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_228' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_229' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_23' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_230' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_231' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_232' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_233' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_234' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_235' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_236' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_237' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_238' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_239' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_24' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_240' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_241' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_242' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_243' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_244' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_245' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_246' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_247' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_248' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_249' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_25' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_250' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_251' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_252' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_253' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_254' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_255' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_256' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_257' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_258' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_259' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_26' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_260' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_261' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_262' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_263' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_264' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_265' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_266' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_267' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_268' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_269' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_27' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_270' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_271' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_272' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_273' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_274' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_275' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_276' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_277' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_278' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_279' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_28' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_280' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_281' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_282' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_283' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_284' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_285' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_286' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_287' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_288' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_289' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_29' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_290' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_291' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_292' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_293' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_294' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_295' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_296' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_297' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_298' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_299' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_3' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_30' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_300' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_301' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_302' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_303' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_304' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_305' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_306' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_307' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_308' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_309' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_31' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_310' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_311' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_312' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_313' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_314' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_315' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_316' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_317' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_318' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_319' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_32' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_320' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_321' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_322' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_323' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_324' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_325' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_326' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_327' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_328' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_329' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_33' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_330' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_331' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_332' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_333' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_334' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_335' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_336' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_337' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_338' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_339' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_34' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_340' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_341' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_342' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_343' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_344' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_345' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_346' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_347' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_348' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_349' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_35' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_350' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_351' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_352' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_353' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_354' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_355' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_356' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_357' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_358' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_359' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_36' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_360' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_361' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_362' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_363' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_364' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_365' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_366' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_367' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_368' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_369' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_37' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_370' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_38' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_39' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_4' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_40' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_41' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_42' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_43' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_44' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_45' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_46' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_47' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_48' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_49' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_5' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_50' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_51' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_52' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_53' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_54' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_55' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_56' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_57' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_58' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_59' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_6' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_60' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_61' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_62' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_63' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_64' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_65' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_66' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_67' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_68' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_69' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_7' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_70' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_71' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_72' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_73' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_74' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_75' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_76' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_77' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_78' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_79' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_8' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_80' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_81' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_82' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_83' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_84' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_85' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_86' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_87' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_88' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_89' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_9' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_90' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_91' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_92' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_93' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_94' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_95' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_96' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_97' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_98' does not depend on any axioms +'LexLeanTarget.TargetSemantics.destruct.eq_99' does not depend on any axioms +'LexLeanTarget.TargetSemantics.fromStrings.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.fromStrings.eq_2' does not depend on any axioms +'LexLeanTarget.TargetSemantics.fromStrings.eq_def' does not depend on any axioms +'LexLeanTarget.TargetSemantics.primitive.eq_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_10' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_100' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1000' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1001' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1002' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1003' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1004' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1005' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1006' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1007' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1008' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1009' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_101' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1010' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1011' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1012' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1013' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1014' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1015' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1016' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1017' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1018' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1019' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_102' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1020' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1021' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1022' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1023' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1024' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1025' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1026' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1027' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1028' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1029' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_103' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1030' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1031' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1032' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1033' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1034' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1035' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1036' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1037' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1038' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1039' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_104' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1040' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1041' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1042' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1043' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1044' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1045' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1046' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1047' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1048' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1049' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_105' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1050' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1051' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1052' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1053' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1054' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1055' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1056' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1057' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1058' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1059' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_106' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1060' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1061' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1062' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1063' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1064' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1065' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1066' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1067' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1068' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1069' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_107' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1070' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1071' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1072' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1073' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1074' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1075' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1076' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1077' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1078' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1079' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_108' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1080' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1081' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1082' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1083' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1084' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1085' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1086' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1087' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1088' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1089' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_109' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1090' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1091' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1092' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1093' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1094' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1095' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1096' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1097' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1098' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1099' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_11' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_110' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1100' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1101' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1102' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1103' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1104' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1105' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1106' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1107' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1108' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1109' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_111' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1110' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1111' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1112' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1113' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1114' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1115' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1116' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1117' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1118' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1119' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_112' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1120' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1121' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1122' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1123' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1124' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1125' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1126' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1127' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1128' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1129' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_113' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1130' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1131' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1132' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1133' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1134' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1135' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1136' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1137' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1138' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1139' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_114' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1140' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1141' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1142' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1143' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1144' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1145' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1146' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1147' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1148' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1149' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_115' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1150' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1151' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1152' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1153' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1154' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1155' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1156' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1157' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1158' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1159' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_116' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1160' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1161' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1162' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1163' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1164' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1165' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1166' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1167' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1168' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1169' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_117' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1170' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1171' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1172' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1173' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1174' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1175' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1176' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1177' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1178' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1179' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_118' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1180' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1181' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1182' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1183' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1184' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1185' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1186' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1187' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1188' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1189' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_119' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1190' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1191' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1192' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1193' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1194' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1195' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1196' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1197' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1198' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1199' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_12' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_120' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1200' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1201' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1202' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1203' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1204' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1205' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1206' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1207' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1208' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1209' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_121' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1210' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1211' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1212' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1213' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1214' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1215' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1216' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1217' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1218' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1219' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_122' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1220' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1221' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1222' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1223' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1224' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1225' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1226' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1227' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1228' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1229' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_123' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1230' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1231' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1232' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1233' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1234' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1235' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1236' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1237' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1238' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1239' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_124' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1240' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1241' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1242' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1243' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1244' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1245' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1246' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1247' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1248' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1249' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_125' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1250' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1251' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1252' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1253' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1254' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1255' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1256' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1257' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1258' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1259' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_126' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1260' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1261' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1262' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1263' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1264' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1265' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1266' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1267' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1268' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1269' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_127' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1270' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1271' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1272' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1273' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1274' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1275' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1276' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1277' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1278' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1279' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_128' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1280' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1281' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1282' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1283' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1284' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1285' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1286' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1287' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1288' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1289' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_129' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1290' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1291' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1292' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1293' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1294' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1295' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1296' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1297' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1298' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1299' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_13' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_130' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1300' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1301' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1302' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1303' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1304' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1305' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1306' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1307' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1308' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1309' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_131' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1310' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1311' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1312' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1313' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1314' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1315' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1316' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1317' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1318' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1319' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_132' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1320' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1321' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1322' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1323' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1324' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1325' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1326' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1327' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1328' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1329' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_133' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1330' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1331' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1332' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1333' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1334' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1335' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1336' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1337' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1338' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1339' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_134' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1340' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1341' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1342' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1343' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1344' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1345' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1346' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1347' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1348' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1349' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_135' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1350' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1351' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1352' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1353' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1354' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1355' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1356' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1357' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1358' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1359' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_136' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1360' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1361' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1362' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1363' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1364' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1365' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1366' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1367' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1368' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1369' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_137' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1370' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1371' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1372' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1373' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1374' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1375' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1376' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1377' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1378' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1379' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_138' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1380' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1381' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1382' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1383' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1384' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1385' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1386' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1387' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1388' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1389' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_139' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1390' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1391' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1392' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1393' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1394' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1395' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1396' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1397' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1398' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1399' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_14' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_140' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1400' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1401' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1402' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1403' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1404' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1405' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1406' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1407' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1408' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1409' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_141' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1410' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1411' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1412' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1413' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1414' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1415' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1416' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1417' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1418' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1419' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_142' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1420' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1421' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1422' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1423' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1424' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1425' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1426' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1427' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1428' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1429' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_143' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1430' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1431' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1432' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1433' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1434' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1435' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1436' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1437' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1438' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1439' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_144' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1440' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1441' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1442' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1443' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1444' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1445' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1446' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1447' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1448' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1449' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_145' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1450' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1451' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1452' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1453' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1454' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1455' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1456' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1457' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1458' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1459' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_146' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1460' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1461' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1462' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1463' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1464' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1465' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1466' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1467' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1468' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1469' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_147' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1470' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1471' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1472' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1473' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1474' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1475' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1476' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1477' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1478' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1479' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_148' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1480' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1481' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1482' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1483' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1484' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1485' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1486' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1487' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1488' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1489' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_149' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1490' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1491' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1492' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1493' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1494' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1495' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1496' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1497' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1498' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1499' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_15' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_150' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1500' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1501' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1502' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1503' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1504' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1505' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1506' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1507' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1508' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1509' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_151' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1510' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1511' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1512' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1513' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1514' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1515' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1516' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1517' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1518' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1519' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_152' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1520' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1521' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1522' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1523' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1524' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1525' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1526' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1527' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1528' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1529' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_153' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1530' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1531' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1532' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1533' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1534' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1535' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1536' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1537' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1538' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1539' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_154' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1540' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1541' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1542' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1543' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1544' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1545' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1546' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1547' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1548' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1549' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_155' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1550' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1551' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1552' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1553' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1554' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1555' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1556' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1557' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1558' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1559' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_156' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1560' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1561' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1562' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1563' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1564' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1565' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1566' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1567' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1568' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1569' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_157' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1570' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1571' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1572' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1573' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1574' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1575' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1576' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1577' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1578' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1579' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_158' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1580' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1581' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1582' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1583' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1584' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1585' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1586' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1587' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1588' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1589' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_159' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1590' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1591' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1592' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1593' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1594' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1595' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1596' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1597' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1598' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1599' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_16' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_160' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1600' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1601' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1602' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1603' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1604' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1605' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1606' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1607' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1608' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1609' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_161' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1610' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1611' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1612' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1613' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1614' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1615' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1616' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1617' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1618' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1619' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_162' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1620' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1621' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1622' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1623' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1624' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1625' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1626' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1627' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1628' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1629' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_163' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1630' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1631' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1632' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1633' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1634' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1635' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1636' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1637' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1638' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1639' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_164' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1640' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1641' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1642' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1643' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1644' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1645' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1646' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1647' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1648' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1649' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_165' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1650' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1651' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1652' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1653' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1654' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1655' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1656' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1657' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1658' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1659' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_166' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1660' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1661' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1662' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1663' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1664' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1665' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1666' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1667' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1668' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1669' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_167' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1670' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1671' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1672' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1673' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1674' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1675' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1676' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1677' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1678' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1679' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_168' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1680' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1681' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1682' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1683' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1684' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1685' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1686' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1687' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1688' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1689' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_169' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1690' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1691' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1692' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1693' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1694' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1695' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1696' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1697' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1698' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1699' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_17' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_170' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1700' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1701' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1702' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1703' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1704' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1705' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1706' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1707' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1708' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1709' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_171' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1710' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1711' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1712' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1713' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1714' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1715' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1716' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1717' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1718' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1719' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_172' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1720' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1721' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1722' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1723' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1724' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1725' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1726' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1727' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1728' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1729' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_173' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1730' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1731' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1732' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1733' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1734' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1735' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1736' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1737' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1738' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1739' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_174' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1740' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1741' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1742' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1743' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1744' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1745' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1746' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1747' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1748' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1749' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_175' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1750' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1751' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1752' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1753' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1754' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1755' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1756' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1757' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1758' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1759' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_176' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1760' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1761' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1762' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1763' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1764' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1765' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1766' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1767' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1768' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1769' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_177' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1770' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1771' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1772' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1773' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1774' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1775' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1776' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1777' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1778' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1779' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_178' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1780' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1781' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1782' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1783' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1784' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1785' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1786' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1787' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1788' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1789' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_179' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1790' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1791' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1792' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1793' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1794' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1795' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1796' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1797' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1798' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1799' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_18' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_180' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1800' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1801' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1802' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1803' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1804' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1805' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1806' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1807' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1808' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1809' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_181' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1810' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1811' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1812' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1813' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1814' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1815' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1816' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1817' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1818' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1819' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_182' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1820' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1821' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1822' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1823' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1824' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1825' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1826' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1827' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1828' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1829' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_183' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1830' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1831' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1832' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1833' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1834' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1835' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1836' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1837' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1838' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1839' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_184' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1840' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1841' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1842' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1843' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1844' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1845' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1846' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1847' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1848' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1849' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_185' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1850' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1851' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1852' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1853' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1854' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1855' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1856' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1857' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1858' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1859' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_186' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1860' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1861' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1862' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1863' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1864' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1865' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1866' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1867' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1868' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1869' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_187' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1870' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1871' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1872' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1873' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1874' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1875' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1876' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1877' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1878' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1879' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_188' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1880' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1881' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1882' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1883' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1884' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1885' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1886' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1887' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1888' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1889' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_189' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1890' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1891' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1892' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1893' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1894' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1895' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1896' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1897' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1898' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1899' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_19' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_190' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1900' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1901' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1902' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1903' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1904' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1905' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1906' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1907' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1908' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1909' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_191' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1910' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1911' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1912' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1913' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1914' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1915' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1916' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1917' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1918' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1919' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_192' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1920' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1921' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1922' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1923' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1924' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1925' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1926' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1927' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1928' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1929' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_193' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1930' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1931' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1932' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1933' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1934' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1935' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1936' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1937' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1938' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1939' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_194' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1940' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1941' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1942' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1943' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1944' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1945' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1946' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1947' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1948' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1949' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_195' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1950' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1951' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1952' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1953' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1954' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1955' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1956' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1957' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1958' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1959' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_196' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1960' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1961' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1962' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1963' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1964' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1965' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1966' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1967' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1968' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1969' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_197' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1970' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1971' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1972' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1973' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1974' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1975' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1976' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1977' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1978' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1979' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_198' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1980' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1981' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1982' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1983' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1984' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1985' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1986' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1987' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1988' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1989' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_199' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1990' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1991' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1992' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1993' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1994' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1995' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1996' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1997' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1998' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_1999' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_20' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_200' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2000' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2001' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2002' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2003' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2004' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2005' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2006' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2007' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2008' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2009' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_201' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2010' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2011' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2012' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2013' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2014' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2015' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2016' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2017' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2018' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2019' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_202' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2020' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2021' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2022' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2023' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2024' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2025' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2026' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2027' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2028' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2029' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_203' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2030' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2031' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2032' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2033' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2034' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2035' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2036' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2037' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2038' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2039' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_204' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2040' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2041' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2042' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2043' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2044' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2045' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2046' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2047' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2048' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2049' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_205' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2050' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2051' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2052' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2053' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2054' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2055' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2056' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2057' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2058' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2059' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_206' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2060' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2061' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2062' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2063' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2064' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2065' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2066' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2067' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2068' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2069' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_207' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2070' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2071' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2072' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2073' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2074' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2075' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2076' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2077' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2078' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2079' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_208' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2080' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2081' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2082' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2083' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2084' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2085' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2086' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2087' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2088' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2089' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_209' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2090' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2091' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2092' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2093' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2094' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2095' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2096' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2097' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2098' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2099' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_21' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_210' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2100' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2101' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2102' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2103' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2104' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2105' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2106' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2107' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2108' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2109' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_211' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2110' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2111' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2112' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2113' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2114' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2115' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2116' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2117' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2118' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2119' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_212' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2120' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2121' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2122' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2123' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2124' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2125' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2126' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2127' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2128' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2129' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_213' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2130' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2131' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2132' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2133' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2134' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2135' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2136' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2137' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2138' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2139' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_214' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2140' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2141' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2142' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2143' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2144' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2145' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2146' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2147' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2148' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2149' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_215' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2150' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2151' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2152' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2153' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2154' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2155' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2156' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2157' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2158' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2159' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_216' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2160' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2161' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2162' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2163' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2164' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2165' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2166' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2167' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2168' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2169' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_217' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2170' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2171' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2172' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2173' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2174' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2175' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2176' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2177' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2178' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2179' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_218' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2180' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2181' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2182' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2183' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2184' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2185' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2186' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2187' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2188' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2189' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_219' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2190' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2191' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2192' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2193' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2194' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2195' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2196' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2197' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2198' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2199' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_22' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_220' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2200' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2201' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2202' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2203' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2204' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2205' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2206' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2207' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2208' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2209' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_221' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2210' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2211' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2212' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2213' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2214' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2215' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2216' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2217' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2218' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2219' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_222' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2220' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2221' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2222' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2223' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2224' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2225' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2226' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2227' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2228' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2229' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_223' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2230' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2231' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2232' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2233' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2234' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2235' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2236' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2237' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2238' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2239' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_224' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2240' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2241' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2242' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2243' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2244' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2245' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2246' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2247' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2248' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2249' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_225' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2250' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2251' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2252' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2253' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2254' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2255' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2256' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2257' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2258' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2259' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_226' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2260' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2261' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2262' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2263' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2264' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2265' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2266' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2267' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2268' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2269' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_227' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2270' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2271' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2272' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2273' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2274' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2275' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2276' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2277' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2278' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2279' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_228' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2280' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2281' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2282' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2283' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2284' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2285' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2286' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2287' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2288' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2289' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_229' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2290' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2291' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2292' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2293' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2294' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2295' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2296' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2297' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2298' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2299' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_23' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_230' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2300' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2301' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2302' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2303' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2304' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2305' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2306' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2307' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2308' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2309' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_231' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2310' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2311' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2312' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2313' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2314' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2315' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2316' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2317' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2318' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2319' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_232' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2320' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2321' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2322' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2323' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2324' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2325' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2326' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2327' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2328' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2329' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_233' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2330' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2331' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2332' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2333' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2334' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2335' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2336' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2337' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2338' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2339' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_234' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2340' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2341' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2342' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2343' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2344' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2345' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2346' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2347' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2348' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2349' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_235' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2350' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2351' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2352' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2353' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2354' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2355' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2356' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2357' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2358' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2359' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_236' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2360' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2361' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2362' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2363' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2364' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2365' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2366' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2367' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2368' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2369' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_237' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2370' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2371' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2372' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2373' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2374' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2375' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2376' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2377' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2378' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2379' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_238' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2380' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2381' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2382' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2383' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2384' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2385' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2386' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2387' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2388' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2389' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_239' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2390' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2391' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2392' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2393' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2394' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2395' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2396' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2397' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2398' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2399' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_24' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_240' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2400' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2401' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2402' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2403' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2404' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2405' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2406' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2407' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2408' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2409' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_241' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2410' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2411' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2412' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2413' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2414' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2415' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2416' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2417' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2418' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2419' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_242' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2420' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2421' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2422' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2423' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2424' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2425' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2426' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2427' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2428' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2429' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_243' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2430' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2431' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2432' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2433' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2434' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2435' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2436' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2437' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2438' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2439' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_244' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2440' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2441' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2442' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2443' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2444' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2445' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2446' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2447' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2448' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2449' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_245' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2450' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2451' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2452' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2453' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2454' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2455' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2456' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2457' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2458' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2459' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_246' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2460' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2461' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2462' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2463' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2464' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2465' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2466' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2467' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2468' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2469' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_247' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2470' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2471' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2472' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2473' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2474' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2475' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2476' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2477' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2478' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2479' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_248' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2480' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2481' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2482' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2483' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2484' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2485' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2486' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2487' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2488' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2489' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_249' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2490' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2491' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2492' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2493' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2494' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2495' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2496' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2497' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2498' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2499' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_25' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_250' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2500' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2501' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2502' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2503' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2504' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2505' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2506' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2507' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2508' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2509' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_251' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2510' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2511' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2512' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2513' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2514' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2515' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2516' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2517' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2518' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2519' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_252' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2520' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2521' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2522' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2523' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2524' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2525' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2526' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2527' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2528' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2529' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_253' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2530' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2531' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2532' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2533' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2534' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2535' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2536' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2537' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2538' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2539' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_254' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2540' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2541' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2542' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2543' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2544' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2545' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2546' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2547' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2548' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2549' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_255' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2550' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2551' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2552' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2553' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2554' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2555' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2556' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2557' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2558' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2559' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_256' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2560' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2561' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2562' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2563' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2564' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2565' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2566' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2567' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2568' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2569' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_257' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2570' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2571' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2572' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2573' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2574' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2575' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2576' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2577' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2578' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2579' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_258' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2580' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2581' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2582' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2583' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2584' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2585' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2586' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2587' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2588' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2589' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_259' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2590' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2591' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2592' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2593' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2594' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2595' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2596' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2597' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2598' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2599' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_26' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_260' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2600' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2601' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2602' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2603' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2604' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2605' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2606' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2607' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2608' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2609' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_261' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2610' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2611' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2612' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2613' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2614' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2615' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2616' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2617' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2618' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2619' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_262' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2620' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2621' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2622' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2623' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2624' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2625' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2626' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2627' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2628' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2629' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_263' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2630' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2631' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2632' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2633' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2634' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2635' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2636' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2637' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2638' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2639' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_264' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2640' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2641' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2642' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2643' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2644' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2645' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2646' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2647' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2648' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2649' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_265' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2650' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2651' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2652' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2653' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2654' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2655' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2656' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2657' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2658' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2659' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_266' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2660' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2661' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2662' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2663' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2664' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2665' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2666' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2667' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2668' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2669' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_267' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2670' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2671' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2672' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2673' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2674' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2675' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2676' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2677' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2678' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2679' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_268' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2680' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2681' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2682' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2683' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2684' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2685' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2686' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2687' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2688' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2689' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_269' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2690' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2691' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2692' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2693' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2694' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2695' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2696' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2697' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2698' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2699' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_27' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_270' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2700' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2701' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2702' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2703' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2704' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2705' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2706' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2707' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2708' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2709' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_271' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2710' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2711' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2712' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2713' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2714' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2715' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2716' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2717' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2718' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2719' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_272' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2720' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2721' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2722' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2723' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2724' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2725' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2726' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2727' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2728' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2729' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_273' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2730' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2731' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2732' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2733' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2734' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2735' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2736' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2737' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2738' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2739' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_274' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2740' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2741' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2742' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2743' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2744' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2745' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2746' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2747' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2748' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2749' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_275' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2750' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2751' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2752' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2753' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2754' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2755' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2756' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2757' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2758' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2759' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_276' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2760' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2761' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2762' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2763' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2764' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2765' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2766' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2767' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2768' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2769' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_277' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2770' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2771' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2772' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2773' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2774' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2775' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2776' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2777' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2778' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2779' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_278' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2780' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2781' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2782' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2783' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2784' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2785' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2786' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2787' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2788' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2789' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_279' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2790' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2791' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2792' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2793' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2794' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2795' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2796' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2797' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2798' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2799' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_28' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_280' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2800' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2801' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2802' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2803' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2804' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2805' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2806' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2807' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2808' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2809' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_281' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2810' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2811' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2812' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2813' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2814' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2815' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2816' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2817' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2818' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2819' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_282' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2820' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2821' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2822' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2823' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2824' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2825' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2826' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2827' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2828' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2829' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_283' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2830' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2831' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2832' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2833' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2834' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2835' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2836' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2837' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2838' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2839' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_284' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2840' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2841' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2842' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2843' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2844' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2845' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2846' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2847' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2848' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2849' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_285' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2850' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2851' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2852' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2853' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2854' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2855' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2856' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2857' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2858' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2859' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_286' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2860' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2861' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2862' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2863' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2864' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2865' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2866' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2867' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2868' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2869' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_287' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2870' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2871' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2872' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2873' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2874' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2875' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2876' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2877' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2878' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2879' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_288' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2880' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2881' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2882' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2883' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2884' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2885' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2886' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2887' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2888' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2889' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_289' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2890' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2891' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2892' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2893' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2894' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2895' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2896' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2897' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2898' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2899' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_29' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_290' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2900' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2901' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2902' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2903' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2904' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2905' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2906' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2907' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2908' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2909' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_291' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2910' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2911' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2912' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2913' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2914' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2915' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2916' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2917' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2918' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2919' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_292' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2920' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2921' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2922' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2923' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2924' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2925' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2926' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2927' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2928' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2929' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_293' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2930' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2931' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2932' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2933' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2934' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2935' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2936' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2937' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2938' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2939' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_294' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2940' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2941' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2942' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2943' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2944' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2945' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2946' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2947' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2948' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2949' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_295' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2950' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2951' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2952' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2953' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2954' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2955' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2956' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2957' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2958' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2959' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_296' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2960' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2961' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2962' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2963' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2964' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2965' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2966' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2967' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2968' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2969' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_297' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2970' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2971' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2972' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2973' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2974' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2975' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2976' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2977' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2978' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2979' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_298' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2980' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2981' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2982' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2983' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2984' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2985' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2986' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2987' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2988' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2989' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_299' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2990' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2991' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2992' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2993' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2994' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2995' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2996' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2997' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2998' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_2999' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_30' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_300' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3000' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3001' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3002' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3003' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3004' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3005' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3006' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3007' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3008' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3009' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_301' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3010' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3011' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3012' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3013' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3014' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3015' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3016' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3017' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3018' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3019' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_302' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3020' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3021' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3022' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3023' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3024' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3025' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3026' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3027' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3028' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3029' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_303' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3030' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3031' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3032' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3033' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3034' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3035' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3036' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3037' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3038' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3039' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_304' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3040' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3041' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3042' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3043' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3044' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3045' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3046' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3047' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3048' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3049' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_305' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3050' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3051' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3052' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3053' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3054' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3055' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3056' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3057' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3058' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3059' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_306' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3060' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3061' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3062' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3063' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3064' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3065' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3066' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3067' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3068' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3069' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_307' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3070' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3071' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3072' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3073' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3074' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3075' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3076' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3077' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3078' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3079' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_308' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3080' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3081' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3082' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3083' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3084' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3085' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3086' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3087' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3088' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3089' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_309' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3090' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3091' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3092' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3093' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3094' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3095' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3096' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3097' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3098' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3099' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_31' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_310' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3100' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3101' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3102' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3103' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3104' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3105' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3106' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3107' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3108' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3109' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_311' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3110' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3111' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3112' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3113' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3114' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3115' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3116' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3117' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3118' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3119' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_312' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3120' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3121' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3122' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3123' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3124' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3125' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3126' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3127' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3128' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3129' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_313' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3130' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3131' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3132' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3133' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3134' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3135' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3136' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3137' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3138' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3139' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_314' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3140' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3141' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3142' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3143' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3144' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3145' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3146' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3147' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3148' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3149' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_315' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3150' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3151' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3152' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3153' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3154' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3155' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3156' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3157' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3158' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3159' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_316' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3160' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3161' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3162' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3163' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3164' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3165' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3166' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3167' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3168' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3169' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_317' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3170' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3171' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3172' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3173' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3174' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3175' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3176' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3177' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3178' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3179' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_318' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3180' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3181' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3182' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3183' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3184' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3185' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3186' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3187' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3188' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3189' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_319' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3190' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3191' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3192' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3193' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3194' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3195' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3196' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3197' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3198' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3199' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_32' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_320' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3200' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3201' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3202' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3203' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3204' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3205' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3206' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3207' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3208' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3209' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_321' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3210' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3211' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3212' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3213' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3214' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3215' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3216' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3217' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3218' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3219' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_322' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3220' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3221' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3222' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3223' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3224' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3225' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3226' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3227' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3228' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3229' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_323' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3230' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3231' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3232' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3233' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3234' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3235' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3236' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3237' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3238' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3239' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_324' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3240' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3241' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3242' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3243' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3244' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3245' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3246' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3247' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3248' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3249' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_325' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3250' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3251' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3252' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3253' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3254' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3255' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3256' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3257' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3258' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3259' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_326' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3260' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3261' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3262' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3263' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3264' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3265' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3266' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3267' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3268' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3269' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_327' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3270' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3271' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3272' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3273' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3274' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3275' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3276' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3277' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3278' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3279' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_328' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3280' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3281' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3282' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3283' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3284' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3285' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3286' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3287' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3288' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3289' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_329' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3290' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3291' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3292' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3293' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3294' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3295' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3296' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3297' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3298' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3299' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_33' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_330' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3300' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3301' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3302' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3303' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3304' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3305' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3306' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3307' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3308' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3309' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_331' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3310' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3311' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3312' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3313' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3314' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3315' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3316' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3317' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3318' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3319' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_332' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3320' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3321' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3322' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3323' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3324' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3325' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3326' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3327' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3328' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3329' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_333' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3330' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3331' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3332' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3333' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3334' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3335' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3336' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3337' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3338' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3339' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_334' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3340' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3341' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3342' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3343' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3344' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3345' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3346' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3347' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3348' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3349' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_335' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3350' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3351' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3352' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3353' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3354' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3355' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3356' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3357' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3358' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3359' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_336' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3360' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3361' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3362' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3363' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3364' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3365' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3366' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3367' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3368' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3369' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_337' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3370' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3371' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3372' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3373' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3374' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3375' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3376' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3377' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3378' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3379' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_338' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3380' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3381' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3382' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3383' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3384' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3385' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3386' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3387' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3388' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3389' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_339' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3390' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3391' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3392' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3393' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3394' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3395' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3396' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3397' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3398' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3399' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_34' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_340' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3400' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3401' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3402' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3403' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3404' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3405' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3406' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3407' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3408' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3409' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_341' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3410' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3411' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3412' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3413' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3414' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3415' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3416' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3417' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3418' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3419' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_342' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3420' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3421' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3422' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3423' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3424' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_3425' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_343' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_344' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_345' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_346' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_347' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_348' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_349' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_35' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_350' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_351' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_352' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_353' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_354' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_355' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_356' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_357' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_358' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_359' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_36' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_360' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_361' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_362' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_363' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_364' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_365' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_366' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_367' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_368' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_369' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_37' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_370' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_371' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_372' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_373' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_374' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_375' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_376' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_377' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_378' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_379' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_38' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_380' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_381' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_382' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_383' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_384' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_385' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_386' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_387' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_388' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_389' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_39' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_390' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_391' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_392' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_393' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_394' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_395' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_396' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_397' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_398' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_399' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_4' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_40' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_400' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_401' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_402' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_403' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_404' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_405' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_406' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_407' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_408' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_409' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_41' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_410' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_411' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_412' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_413' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_414' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_415' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_416' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_417' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_418' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_419' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_42' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_420' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_421' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_422' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_423' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_424' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_425' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_426' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_427' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_428' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_429' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_43' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_430' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_431' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_432' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_433' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_434' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_435' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_436' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_437' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_438' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_439' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_44' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_440' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_441' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_442' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_443' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_444' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_445' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_446' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_447' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_448' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_449' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_45' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_450' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_451' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_452' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_453' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_454' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_455' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_456' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_457' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_458' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_459' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_46' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_460' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_461' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_462' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_463' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_464' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_465' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_466' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_467' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_468' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_469' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_47' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_470' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_471' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_472' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_473' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_474' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_475' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_476' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_477' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_478' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_479' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_48' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_480' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_481' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_482' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_483' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_484' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_485' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_486' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_487' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_488' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_489' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_49' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_490' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_491' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_492' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_493' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_494' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_495' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_496' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_497' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_498' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_499' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_5' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_50' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_500' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_501' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_502' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_503' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_504' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_505' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_506' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_507' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_508' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_509' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_51' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_510' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_511' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_512' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_513' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_514' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_515' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_516' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_517' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_518' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_519' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_52' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_520' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_521' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_522' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_523' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_524' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_525' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_526' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_527' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_528' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_529' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_53' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_530' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_531' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_532' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_533' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_534' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_535' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_536' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_537' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_538' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_539' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_54' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_540' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_541' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_542' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_543' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_544' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_545' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_546' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_547' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_548' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_549' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_55' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_550' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_551' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_552' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_553' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_554' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_555' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_556' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_557' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_558' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_559' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_56' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_560' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_561' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_562' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_563' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_564' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_565' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_566' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_567' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_568' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_569' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_57' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_570' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_571' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_572' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_573' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_574' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_575' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_576' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_577' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_578' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_579' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_58' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_580' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_581' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_582' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_583' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_584' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_585' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_586' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_587' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_588' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_589' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_59' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_590' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_591' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_592' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_593' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_594' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_595' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_596' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_597' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_598' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_599' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_6' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_60' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_600' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_601' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_602' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_603' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_604' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_605' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_606' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_607' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_608' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_609' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_61' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_610' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_611' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_612' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_613' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_614' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_615' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_616' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_617' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_618' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_619' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_62' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_620' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_621' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_622' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_623' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_624' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_625' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_626' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_627' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_628' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_629' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_63' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_630' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_631' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_632' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_633' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_634' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_635' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_636' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_637' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_638' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_639' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_64' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_640' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_641' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_642' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_643' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_644' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_645' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_646' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_647' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_648' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_649' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_65' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_650' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_651' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_652' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_653' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_654' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_655' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_656' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_657' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_658' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_659' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_66' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_660' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_661' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_662' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_663' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_664' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_665' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_666' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_667' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_668' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_669' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_67' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_670' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_671' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_672' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_673' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_674' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_675' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_676' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_677' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_678' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_679' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_68' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_680' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_681' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_682' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_683' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_684' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_685' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_686' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_687' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_688' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_689' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_69' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_690' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_691' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_692' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_693' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_694' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_695' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_696' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_697' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_698' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_699' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_7' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_70' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_700' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_701' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_702' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_703' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_704' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_705' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_706' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_707' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_708' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_709' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_71' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_710' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_711' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_712' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_713' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_714' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_715' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_716' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_717' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_718' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_719' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_72' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_720' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_721' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_722' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_723' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_724' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_725' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_726' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_727' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_728' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_729' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_73' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_730' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_731' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_732' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_733' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_734' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_735' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_736' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_737' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_738' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_739' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_74' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_740' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_741' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_742' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_743' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_744' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_745' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_746' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_747' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_748' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_749' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_75' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_750' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_751' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_752' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_753' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_754' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_755' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_756' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_757' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_758' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_759' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_76' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_760' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_761' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_762' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_763' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_764' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_765' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_766' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_767' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_768' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_769' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_77' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_770' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_771' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_772' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_773' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_774' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_775' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_776' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_777' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_778' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_779' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_78' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_780' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_781' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_782' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_783' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_784' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_785' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_786' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_787' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_788' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_789' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_79' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_790' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_791' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_792' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_793' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_794' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_795' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_796' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_797' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_798' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_799' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_8' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_80' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_800' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_801' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_802' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_803' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_804' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_805' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_806' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_807' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_808' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_809' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_81' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_810' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_811' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_812' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_813' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_814' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_815' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_816' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_817' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_818' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_819' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_82' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_820' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_821' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_822' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_823' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_824' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_825' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_826' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_827' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_828' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_829' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_83' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_830' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_831' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_832' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_833' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_834' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_835' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_836' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_837' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_838' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_839' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_84' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_840' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_841' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_842' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_843' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_844' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_845' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_846' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_847' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_848' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_849' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_85' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_850' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_851' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_852' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_853' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_854' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_855' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_856' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_857' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_858' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_859' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_86' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_860' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_861' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_862' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_863' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_864' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_865' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_866' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_867' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_868' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_869' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_87' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_870' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_871' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_872' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_873' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_874' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_875' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_876' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_877' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_878' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_879' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_88' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_880' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_881' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_882' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_883' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_884' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_885' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_886' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_887' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_888' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_889' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_89' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_890' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_891' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_892' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_893' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_894' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_895' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_896' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_897' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_898' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_899' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_9' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_90' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_900' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_901' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_902' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_903' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_904' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_905' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_906' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_907' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_908' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_909' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_91' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_910' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_911' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_912' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_913' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_914' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_915' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_916' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_917' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_918' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_919' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_92' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_920' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_921' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_922' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_923' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_924' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_925' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_926' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_927' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_928' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_929' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_93' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_930' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_931' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_932' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_933' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_934' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_935' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_936' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_937' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_938' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_939' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_94' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_940' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_941' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_942' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_943' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_944' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_945' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_946' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_947' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_948' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_949' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_95' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_950' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_951' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_952' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_953' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_954' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_955' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_956' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_957' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_958' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_959' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_96' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_960' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_961' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_962' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_963' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_964' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_965' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_966' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_967' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_968' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_969' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_97' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_970' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_971' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_972' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_973' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_974' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_975' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_976' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_977' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_978' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_979' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_98' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_980' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_981' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_982' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_983' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_984' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_985' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_986' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_987' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_988' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_989' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_99' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_990' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_991' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_992' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_993' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_994' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_995' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_996' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_997' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_998' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.TargetSemantics.primitive.eq_999' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.adtFields.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_11.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_12.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_13.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_12.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.armOuter.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.armPat.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.armPat_outer' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.boxedOf.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.boxedOne.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.boxedOne' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindOf_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.bp_entries._simp_1_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.simplePat' depends on axioms: [propext] +'LexLeanPreservation.Rust.bp_entries.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf' depends on axioms: [propext] +'LexLeanPreservation.Rust.isWild_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.bp_entries._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.bp_entries' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.directPat_cons._simp_1_4' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.identBoxed_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.identLocal_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.loadOf_spec' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.directPat_cons' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.directPat_len.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat_nil' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat_len._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.directPat_len' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.directPat_loads._simp_1_27' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat_loads._simp_1_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat_loads.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_none._simp_1_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_none._simp_1_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_none.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rlookup_append' depends on axioms: [propext] +'LexLeanPreservation.Rust.same_boxed_boxed' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_none._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_boxed_none' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_local_none._simp_1_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_local_none._simp_1_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_local_none.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.same_local_local' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_local_none._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_local_none' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rlookup_boxed_local' depends on axioms: [propext] +'LexLeanPreservation.Rust.rlookup_local_boxed' depends on axioms: [propext] +'LexLeanPreservation.Rust.rlookup_local_single' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat_loads._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.directPat_loads' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_boxed_some._simp_1_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_some._simp_1_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_some.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_boxed_some._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.entries_boxed_some' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.envRel_locals' depends on axioms: [propext] +'LexLeanPreservation.Rust.fields_wt' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindPatterns_single' depends on axioms: [propext] +'LexLeanPreservation.Rust.outer_bind' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.paramCtx_length.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_length._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_length' depends on axioms: [propext] +'LexLeanPreservation.Rust.armPat_sound' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.bindOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.bindOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOf.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.boxedOne.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_15' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_16' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_17' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.canon.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.covered.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.covered_mem._simp_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.wt_uninh._simp_10' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.covered_mem' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.ctorOf._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctorOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctorOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.ctorOf_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.destruct_canon' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.destruct_excl' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.directPat.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.directPat.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.entriesOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_lookup.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_none_of._simp_1_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_none_of.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.sameIdent_iff' depends on axioms: [propext] +'LexLeanPreservation.Rust.entries_none_of._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_none_of' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.identsDistinct.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.entries_lookup._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.entries_lookup' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.eval_field.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.eval_field._sparseCasesOn_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.eval_field.match_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.eval_field' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.fieldPats.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats.eq_3' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats.eq_4' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats_none._simp_1_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.fieldPats_none.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.fieldPats_none._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.fieldPats_none' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.fieldPats_some._simp_1_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.fieldPats_some.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.fieldPats_some._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.fieldPats_some' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_partRead' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.tyBeq_unit' depends on axioms: [propext] +'LexLeanPreservation.Rust.field_out' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.findArm_some.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.findArm_some._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.findArm_some' depends on axioms: [propext] +'LexLeanPreservation.Rust.findDispatch_some.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.findDispatch_some._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.findDispatch_some' depends on axioms: [propext] +'LexLeanPreservation.Rust.foldStep._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.fresh_ext' depends on axioms: [propext] +'LexLeanPreservation.Rust.identBoxed.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.identBoxed.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.identLocal.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.identLocal.eq_2' does not depend on any axioms +'LexLeanPreservation.Rust.identsDistinct.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.identsDistinct.eq_def' does not depend on any axioms +'LexLeanPreservation.Rust.isWild._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.isWild.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isWild.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.litOf._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.litOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.litOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.loadOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.noClosure._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.noClosure.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.okBlock.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.otherArms.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.otherArms_mem._simp_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.otherArms_mem' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.outer_miss' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.outer_view' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_ext.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_ext._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_ext' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_fresh.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_fresh._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.paramCtx_fresh' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.partRead.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocal.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.patLocals.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.rc_matchOn' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_matchOn_halt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_uncons.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.rc_uncons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rc_scrut' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rca_hit' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rca_miss' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcb_det' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_rebuild.match_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rlookup_eq_of_same' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg_rc' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_rebuild._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rcl_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.readOf_rc' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.realizesM_value' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildArg.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArg_simple' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs.eq_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs.eq_def' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs.eq_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs_simple.match_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs_simple._f' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildArgs_simple' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_14.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuildTail._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuild_rca._simp_1_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.rebuild_rca.match_1_1' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rebuild_value._simp_1_21' depends on axioms: [propext] +'LexLeanPreservation.Rust.single_rebuild' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rebuild_value' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rebuild_rca._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rebuild_rca' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rebuildsArm.eq_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.rlookup_nil' does not depend on any axioms +'LexLeanPreservation.Rust.sem_fieldGen._proof_1_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_fieldGen.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_fieldGen.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.wtl_get.match_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_get._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_get' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_fieldGen' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_fieldHeld' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_fieldRead' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_mCons._simp_1_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.sem_mCons' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_mNil' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchArms._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.tyBeq_refl.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.tyBeq_refl._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.tysBeq_refl.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.tysBeq_refl._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.tyBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.tysBeq_refl' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.uninh_of_inert.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.uninh_of_inert._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh_of_inert' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_uninh.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_uninh._f' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wtl_uninh.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_uninh._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_uninh' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.taken_arm' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchArms' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchPair._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchPair' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.sem_matchRebuilt._proof_1_3' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchRebuilt.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.sem_matchRebuilt' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_10.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_11.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_2.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_3.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_4.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_5.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_6.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_7.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_8.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq._sparseCasesOn_9.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_15' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_16' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_17' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeBeq.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_10' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_11' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_12' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_13' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_14' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_15' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_16' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_17' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_6' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_7' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_8' depends on axioms: [propext] +'LexLeanPreservation.Rust.shapeFields.eq_9' depends on axioms: [propext] +'LexLeanPreservation.Rust.simplePat.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.unboxOf._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.unboxOf.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.unboxOf.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_def' depends on axioms: [propext] +'LexLeanPreservation.Rust.uninh.eq_5' depends on axioms: [propext] +'LexLeanPreservation.Rust.validU.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal.eq_3' depends on axioms: [propext] +'LexLeanPreservation.Rust.viewVal.eq_4' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_uninh' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanTarget.RustSemantics.findArm.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.findArm.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.findArm.eq_def' does not depend on any axioms +'LexLeanTarget.RustSemantics.findDispatch.eq_1' does not depend on any axioms +'LexLeanTarget.RustSemantics.findDispatch.eq_2' does not depend on any axioms +'LexLeanTarget.RustSemantics.findDispatch.eq_3' does not depend on any axioms +'LexLeanTarget.RustSemantics.findDispatch.eq_4' does not depend on any axioms +'LexLeanTarget.RustSemantics.findDispatch.eq_def' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_1' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_2' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_3' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_4' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_5' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_6' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_7' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_8' does not depend on any axioms +'LexLeanTarget.TargetSemantics.sameOrder.eq_9' does not depend on any axioms +'LexLeanPreservation.Rust.fl_of' does not depend on any axioms +'LexLeanPreservation.Rust.fnFallible.eq_1' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of._simp_1_14' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.funSem_of.match_1_10' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of.match_1_12' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of.match_1_2' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of.match_1_4' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of.match_1_6' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of.match_1_8' does not depend on any axioms +'LexLeanPreservation.Rust.funSem_of' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.isTemp.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.isTemp.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.item_ne' depends on axioms: [propext] +'LexLeanPreservation.Rust.kind_ne' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem._sparseCasesOn_1.else_eq' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem.eq_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.plainItem.eq_2' depends on axioms: [propext] +'LexLeanPreservation.Rust.sound._proof_1_1' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sound._proof_1_2' depends on axioms: [propext, Quot.sound] +'LexLeanPreservation.Rust.sound' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.simulate' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.Representable._sparseCasesOn_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.Representable.match_1' depends on axioms: [propext] +'LexLeanPreservation.Rust.Representable._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.RepresentableL.match_1' does not depend on any axioms +'LexLeanPreservation.Rust.RepresentableL._f' does not depend on any axioms +'LexLeanPreservation.Rust.Representable' depends on axioms: [propext] +'LexLeanPreservation.Rust.RepresentableL' depends on axioms: [propext] +'LexLeanPreservation.Rust.Representable._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.RepresentableL._unsafe_rec' does not depend on any axioms +'LexLeanPreservation.Rust.Representable._unsafe_rec' depends on axioms: [propext] +'LexLeanPreservation.Rust.RepresentableL._sunfold' depends on axioms: [propext] +'LexLeanPreservation.Rust.compose' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.rel_ne_stuck' depends on axioms: [propext] +'LexLeanPreservation.Rust.repL_cons' depends on axioms: [propext] +'LexLeanPreservation.Rust.repL_nil' depends on axioms: [propext] +'LexLeanPreservation.Rust.runItem_abort_infallible' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreservation.Rust.wtAll_cons' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_map.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.wtAll_nil' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_map._f' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtAll_map' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_adt' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_bool' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_bytes' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encExcept.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.wt_encExcept' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_list' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encList' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encOption.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.wt_encOption' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encOrdering' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encPair' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_encUnit' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_errorV' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_i16' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_i32' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_i64' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_i8' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_int' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_listEnc' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_nat' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_noneV' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_okV' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_optEnc.match_1_1' does not depend on any axioms +'LexLeanPreservation.Rust.wt_someV' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_optEnc' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_ordering' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_pairV' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_string' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_u16' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_u32' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_u64' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_u8' depends on axioms: [propext] +'LexLeanPreservation.Rust.wt_unitValue' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_cons' depends on axioms: [propext] +'LexLeanPreservation.Rust.wtl_nil' depends on axioms: [propext] +'LexLeanPreservation.encExcept.eq_1' does not depend on any axioms +'LexLeanPreservation.encExcept.eq_2' does not depend on any axioms +'LexLeanPreservation.encOption.eq_1' does not depend on any axioms +'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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.root' depends on axioms: [propext, + Classical.choice, + Quot.sound] +-- statement vocabulary +inductive LexLeanPreservation.Obs : Type +number of parameters: 0 +constructors: +LexLeanPreservation.Obs.value : LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs +LexLeanPreservation.Obs.overflow : LexLeanPreservation.Obs +LexLeanPreservation.Obs.stuck : LexLeanPreservation.Obs +def LexLeanPreservation.Rel : Bool → LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs := +fun fits v => bif fits then LexLeanPreservation.Obs.value v else LexLeanPreservation.Obs.overflow +def LexLeanPreservation.Conv : LexLeanTarget.TargetSyntax.Program → + List (Nat × LexLeanTarget.TargetSyntax.Value) → LexLeanTarget.TargetSyntax.Expr → LexLeanPreservation.Obs → Prop := +fun p env e o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env e) = some o +def LexLeanPreservation.FunRel : LexLeanTarget.TargetSyntax.Program → + Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop := +fun p f args o => + ∃ fn, + LexLeanRuntime.index p.functions f = some fn ∧ + ∃ env, + LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env ∧ + LexLeanPreservation.Conv p env fn.body o +def LexLeanPreservation.RunConv : LexLeanTarget.TargetSyntax.Program → + Nat → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Obs → Prop := +fun p entry args o => ∃ n, LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.run n p entry args) = some o +def LexLeanPreservation.Rust.WT : LexLeanTarget.TargetSyntax.Program → + LexLeanPreservation.Rust.RCrate → + LexLeanPreservation.Rust.Flags → LexLeanTarget.TargetSyntax.Value → LexLeanTarget.TargetSyntax.Ty → Prop := +fun p c A x x_1 => + x.brecOn (LexLeanPreservation.Rust.WT._f p c A) + (fun t f => ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩) x_1 +def LexLeanPreservation.Rust.WTL : LexLeanTarget.TargetSyntax.Program → + LexLeanPreservation.Rust.RCrate → + LexLeanPreservation.Rust.Flags → + List LexLeanTarget.TargetSyntax.Value → List LexLeanTarget.TargetSyntax.Ty → Prop := +fun p c A x x_1 => + (LexLeanTarget.TargetSyntax.Value.brecOn_1 x (LexLeanPreservation.Rust.WT._f p c A) fun t f => + ⟨LexLeanPreservation.Rust.WTL._f p c A t f, LexLeanPreservation.Rust.WTAll._f p c A t f⟩).1 + x_1 +def LexLeanPreservation.Rust.fnIdent : Nat → LexLeanPreservation.Rust.RIdent := +fun f => LexLeanTarget.RustSyntax.Ident.generated LexLeanTarget.RustSyntax.IdentKind.function f +def LexLeanPreservation.Rust.fnFallible : LexLeanPreservation.Rust.RCrate → Nat → Option Bool := +fun c f => + Option.map (fun fn => LexLeanTarget.RustSemantics.fallibleType fn.snd.fst) + (LexLeanTarget.RustSemantics.findFunction c.items (LexLeanPreservation.Rust.fnIdent f)) +def LexLeanPreservation.Rust.RCI : LexLeanPreservation.Rust.RCrate → + LexLeanPreservation.Rust.RIdent → List LexLeanTarget.TargetSyntax.Value → LexLeanPreservation.Rust.ROut → Prop := +fun c f args o => + o ≠ LexLeanTarget.RustSemantics.ROutcome.exhausted ∧ ∃ n, LexLeanTarget.RustSemantics.invoke n c f args = o +def LexLeanPreservation.Rust.Realizes : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop := +fun fl x x_1 => + match x, x_1 with + | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = v + | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.raise => fl = true + | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True + | x, x_2 => False +def LexLeanPreservation.Rust.RealizesFn : Bool → LexLeanPreservation.Obs → LexLeanPreservation.Rust.ROut → Prop := +fun fallible x x_1 => + match x, x_1 with + | LexLeanPreservation.Obs.value v, LexLeanTarget.RustSemantics.ROutcome.value w => w = bif fallible then v.ok else v + | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.value w => + fallible = true ∧ w = LexLeanTarget.TargetSyntax.Value.unit.error + | LexLeanPreservation.Obs.overflow, LexLeanTarget.RustSemantics.ROutcome.abort => True + | x, x_2 => False +def LexLeanPreservation.Rust.FunSem : LexLeanTarget.TargetSyntax.Program → + LexLeanPreservation.Rust.RCrate → LexLeanPreservation.Rust.Flags → Nat → Nat → Prop := +fun p c A n f => + ∀ (fn : LexLeanTarget.TargetSyntax.Function) (args : List LexLeanTarget.TargetSyntax.Value) + (env : List (Nat × LexLeanTarget.TargetSyntax.Value)) (F : Bool), + LexLeanRuntime.index p.functions f = some fn → + LexLeanPreservation.Rust.WTL p c A args fn.types → + LexLeanTarget.TargetSemantics.bindAll fn.parameters args [] = some env → + LexLeanPreservation.Rust.fnFallible c f = some F → + ∀ (o : LexLeanPreservation.Obs), + LexLeanPreservation.obs (LexLeanTarget.TargetSemantics.eval n p env fn.body) = some o → + o ≠ LexLeanPreservation.Obs.stuck → + (∀ (v : LexLeanTarget.TargetSyntax.Value), + o = LexLeanPreservation.Obs.value v → LexLeanPreservation.Rust.WT p c A v fn.result) ∧ + ∃ ro, + LexLeanPreservation.Rust.RealizesFn F o ro ∧ + LexLeanPreservation.Rust.RCI c (LexLeanPreservation.Rust.fnIdent f) args ro +def LexLeanPreservation.someObs : LexLeanPreservation.Obs → LexLeanPreservation.Obs := +fun x => + match x with + | LexLeanPreservation.Obs.value v => LexLeanPreservation.Obs.value v.some + | LexLeanPreservation.Obs.overflow => LexLeanPreservation.Obs.overflow + | LexLeanPreservation.Obs.stuck => LexLeanPreservation.Obs.stuck +def LexLeanPreservation.Rust.Representable : LexLeanTarget.TargetSyntax.Value → Prop := +fun x => x.brecOn LexLeanPreservation.Rust.Representable._f LexLeanPreservation.Rust.RepresentableL._f +def LexLeanPreservation.Rust.RepresentableL : List LexLeanTarget.TargetSyntax.Value → Prop := +fun x => + LexLeanTarget.TargetSyntax.Value.brecOn_1 x LexLeanPreservation.Rust.Representable._f + LexLeanPreservation.Rust.RepresentableL._f +LexLeanPreservation.Rust.runItem_abort_infallible : ∀ (profile : LexLeanTarget.RustSyntax.Profile) + (item : LexLeanTarget.RustSyntax.Item) (values : List LexLeanTarget.TargetSyntax.Value), + LexLeanTarget.RustSemantics.runItem profile item values = LexLeanTarget.RustSemantics.ROutcome.abort → + LexLeanTarget.RustSemantics.itemFallible item = false + diff --git a/stdlib/expected/verify/preserve/crate/R0.rust-std.rs b/stdlib/expected/verify/preserve/crate/R0.rust-std.rs new file mode 100644 index 0000000000..897f76a029 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R0.rust-std.rs @@ -0,0 +1,314 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +pub fn f0(v0: Bytes, v1: Bytes) -> bool { + let m5 = { + let a2 = v0; + let a3 = 0u64; + let a4 = { + let a1 = v1.clone(); + length_bytes(a1) + }; + slice_bytes(a2, a3, a4) + }; + match m5 { + None => { + false + } + Some(v2) => { + let a6 = v2; + let a7 = v1; + equal(a6, a7) + } + } +} diff --git a/stdlib/expected/verify/preserve/crate/R1.rust-std.rs b/stdlib/expected/verify/preserve/crate/R1.rust-std.rs new file mode 100644 index 0000000000..36c5d58d93 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R1.rust-std.rs @@ -0,0 +1,329 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +pub fn f0(v0: Bytes, v1: Bytes) -> bool { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: u64 = { + let a2 = v1.clone(); + length_bytes(a2) + }; + let a3 = v3; + let a4 = v2; + if nat_le(a3, a4) { + let m10 = { + let a7 = v0; + let a8 = { + let a5 = v2; + let a6 = v3; + nat_sub(a5, a6) + }; + let a9 = v3; + slice_bytes(a7, a8, a9) + }; + match m10 { + None => { + false + } + Some(v4) => { + let a11 = v4; + let a12 = v1; + equal(a11, a12) + } + } + } else { + false + } +} diff --git a/stdlib/expected/verify/preserve/crate/R2.rust-std.rs b/stdlib/expected/verify/preserve/crate/R2.rust-std.rs new file mode 100644 index 0000000000..b03ccea5f6 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R2.rust-std.rs @@ -0,0 +1,459 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F5(Bytes), + F6(u64, Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: u64) -> R> { + match self { + Fn0::F5(k0) => Ok(f5(k0.clone(), p0)), + Fn0::F6(k0, k1) => f6(*k0, k1.clone(), p0), + } + } +} + +pub fn f0(v0: Bytes) -> R { + let v1: u64 = f1(v0.clone())?; + let v2: u64 = f2(v0.clone(), v1)?; + Ok(f3(v0, v2, { + let a1 = v1; + let a2 = v2; + nat_sub(a1, a2) + })) +} + +pub fn f1(v0: Bytes) -> R { + let (h3, _) = f4(Fn0::F5(v0.clone()), { + let a4 = v0.clone(); + length_bytes(a4) + }, { + let a5 = v0; + length_bytes(a5) + })?; + Ok(h3) +} + +pub fn f2(v0: Bytes, v1: u64) -> R { + let (h6, _) = f4(Fn0::F6(v1, v0), v1, 0u64)?; + Ok(h6) +} + +pub fn f3(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m10 = { + let a7 = v0; + let a8 = v1; + let a9 = v2; + slice_bytes(a7, a8, a9) + }; + match m10 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f4(v0: Fn0, v1: u64, v2: u64) -> R<(u64, bool)> { + let m11 = v1; + if m11 == 0 { + Ok((v2, false)) + } else { + let v3 = m11 - 1; + let m13 = { + let c12: Fn0 = v0.clone(); + c12.apply(v2)? + }; + match m13 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f4(v0, v3, v4) + } + } + } +} + +pub fn f5(v0: Bytes, v1: u64) -> Option { + let a14 = 0u64; + let a15 = v1; + if nat_lt(a14, a15) { + if f7(v0, { + let a16 = v1; + let a17 = 1u64; + nat_sub(a16, a17) + }) { + Some({ + let a18 = v1; + let a19 = 1u64; + nat_sub(a18, a19) + }) + } else { + None:: + } + } else { + None:: + } +} + +pub fn f6(v0: u64, v1: Bytes, v2: u64) -> R> { + let a20 = v2; + let a21 = v0; + if nat_lt(a20, a21) { + if f7(v1, v2) { + Ok(Some({ + let a22 = v2; + let a23 = 1u64; + nat_add(a22, a23)? + })) + } else { + Ok(None::) + } + } else { + Ok(None::) + } +} + +pub fn f7(v0: Bytes, v1: u64) -> bool { + let m24 = f8(v0, v1); + match m24 { + None => { + false + } + Some(v2) => { + f9(v2) + } + } +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a25 = v0; + let a26 = v1; + index_bytes(a25, a26) +} + +pub fn f9(v0: u8) -> bool { + let a27 = v0; + let a28 = 32u8; + if if if equal(a27, a28) { + true + } else { + let a29 = v0; + let a30 = 9u8; + equal(a29, a30) + } { + true + } else { + let a31 = v0; + let a32 = 10u8; + equal(a31, a32) + } { + true + } else { + let a33 = v0; + let a34 = 12u8; + if equal(a33, a34) { + true + } else { + let a35 = v0; + let a36 = 13u8; + equal(a35, a36) + } + } +} diff --git a/stdlib/expected/verify/preserve/crate/R3.rust-std.rs b/stdlib/expected/verify/preserve/crate/R3.rust-std.rs new file mode 100644 index 0000000000..596323c157 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R3.rust-std.rs @@ -0,0 +1,470 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(u8, Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: (u64, (u64, List))) -> R))>> { + match self { + Fn0::F2(k0, k1) => f2(*k0, k1.clone(), p0), + } + } +} + +#[derive(Clone)] +pub enum Fn1 { + F7, +} + +impl Fn1 { + pub fn apply(&self, p0: List, p1: Bytes) -> List { + match self { + Fn1::F7 => f7(p0, p1), + } + } +} + +pub fn f0(v0: Bytes, v1: u8) -> R> { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: (u64, (u64, List)) = { + let (h2, _) = f1(Fn0::F2(v1, v0.clone()), v2, (0u64, (0u64, List::::nil())))?; + h2 + }; + let v4: u64 = { + let (h3, _) = { + let (_, h4) = v3.clone(); + h4 + }; + h3 + }; + Ok(f3(List::cons(f4(v0, v4, { + let a5 = v2; + let a6 = v4; + nat_sub(a5, a6) + }), { + let (_, h7) = { + let (_, h8) = v3; + h8 + }; + h7 + }))) +} + +pub fn f1(v0: Fn0, v1: u64, v2: (u64, (u64, List))) -> R<((u64, (u64, List)), bool)> { + let m9 = v1; + if m9 == 0 { + Ok((v2, false)) + } else { + let v3 = m9 - 1; + let m11 = { + let c10: Fn0 = v0.clone(); + c10.apply(v2.clone())? + }; + match m11 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: u8, v1: Bytes, v2: (u64, (u64, List))) -> R))>> { + f5(v1, v0, v2) +} + +pub fn f3(v0: List) -> List { + f6(Fn1::F7, List::::nil(), v0) +} + +pub fn f4(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m15 = { + let a12 = v0; + let a13 = v1; + let a14 = v2; + slice_bytes(a12, a13, a14) + }; + match m15 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f5(v0: Bytes, v1: u8, v2: (u64, (u64, List))) -> R))>> { + let v3: u64 = { + let (h16, _) = v2.clone(); + h16 + }; + let v4: u64 = { + let (h17, _) = { + let (_, h18) = v2.clone(); + h18 + }; + h17 + }; + let v5: List = { + let (_, h19) = { + let (_, h20) = v2; + h20 + }; + h19 + }; + let m21 = f8(v0.clone(), v3); + match m21 { + None => { + Ok(None::<(u64, (u64, List))>) + } + Some(v6) => { + let a22 = v6; + let a23 = v1; + if equal(a22, a23) { + Ok(Some(({ + let a24 = v3; + let a25 = 1u64; + nat_add(a24, a25)? + }, ({ + let a26 = v3; + let a27 = 1u64; + nat_add(a26, a27)? + }, List::cons(f4(v0, v4, { + let a28 = v3; + let a29 = v4; + nat_sub(a28, a29) + }), v5))))) + } else { + Ok(Some(({ + let a30 = v3; + let a31 = 1u64; + nat_add(a30, a31)? + }, (v4, v5)))) + } + } + } +} + +pub fn f6(v0: Fn1, v1: List, v2: List) -> List { + let m32 = v2; + match m32.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f6(v0.clone(), { + let c33: Fn1 = v0; + c33.apply(v1, v3) + }, v4) + } + } +} + +pub fn f7(v0: List, v1: Bytes) -> List { + List::cons(v1, v0) +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a34 = v0; + let a35 = v1; + index_bytes(a34, a35) +} diff --git a/stdlib/expected/verify/preserve/crate/R4.rust-std.rs b/stdlib/expected/verify/preserve/crate/R4.rust-std.rs new file mode 100644 index 0000000000..9a36778b6d --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R4.rust-std.rs @@ -0,0 +1,529 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: (u64, (u64, List))) -> R))>> { + match self { + Fn0::F2(k0) => f2(k0.clone(), p0), + } + } +} + +#[derive(Clone)] +pub enum Fn1 { + F7, +} + +impl Fn1 { + pub fn apply(&self, p0: List, p1: Bytes) -> List { + match self { + Fn1::F7 => f7(p0, p1), + } + } +} + +pub fn f0(v0: Bytes) -> R> { + let v1: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v2: (u64, (u64, List)) = { + let (h2, _) = f1(Fn0::F2(v0.clone()), v1, (0u64, (0u64, List::::nil())))?; + h2 + }; + let v3: u64 = { + let (h3, _) = { + let (_, h4) = v2.clone(); + h4 + }; + h3 + }; + let v4: List = { + let (_, h5) = { + let (_, h6) = v2; + h6 + }; + h5 + }; + let a7 = v3; + let a8 = v1; + if nat_lt(a7, a8) { + Ok(f3(List::cons(f4(v0, v3, { + let a9 = v1; + let a10 = v3; + nat_sub(a9, a10) + }), v4))) + } else { + Ok(f3(v4)) + } +} + +pub fn f1(v0: Fn0, v1: u64, v2: (u64, (u64, List))) -> R<((u64, (u64, List)), bool)> { + let m11 = v1; + if m11 == 0 { + Ok((v2, false)) + } else { + let v3 = m11 - 1; + let m13 = { + let c12: Fn0 = v0.clone(); + c12.apply(v2.clone())? + }; + match m13 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: Bytes, v1: (u64, (u64, List))) -> R))>> { + f5(v0, v1) +} + +pub fn f3(v0: List) -> List { + f6(Fn1::F7, List::::nil(), v0) +} + +pub fn f4(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m17 = { + let a14 = v0; + let a15 = v1; + let a16 = v2; + slice_bytes(a14, a15, a16) + }; + match m17 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f5(v0: Bytes, v1: (u64, (u64, List))) -> R))>> { + let v2: u64 = { + let (h18, _) = v1.clone(); + h18 + }; + let v3: u64 = { + let (h19, _) = { + let (_, h20) = v1.clone(); + h20 + }; + h19 + }; + let v4: List = { + let (_, h21) = { + let (_, h22) = v1; + h22 + }; + h21 + }; + let m23 = f8(v0.clone(), v2); + match m23 { + None => { + Ok(None::<(u64, (u64, List))>) + } + Some(v5) => { + let a24 = v5; + let a25 = 10u8; + if equal(a24, a25) { + Ok(Some(({ + let a26 = v2; + let a27 = 1u64; + nat_add(a26, a27)? + }, ({ + let a28 = v2; + let a29 = 1u64; + nat_add(a28, a29)? + }, List::cons(f9(f4(v0, v3, { + let a30 = v2; + let a31 = v3; + nat_sub(a30, a31) + })), v4))))) + } else { + Ok(Some(({ + let a32 = v2; + let a33 = 1u64; + nat_add(a32, a33)? + }, (v3, v4)))) + } + } + } +} + +pub fn f6(v0: Fn1, v1: List, v2: List) -> List { + let m34 = v2; + match m34.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f6(v0.clone(), { + let c35: Fn1 = v0; + c35.apply(v1, v3) + }, v4) + } + } +} + +pub fn f7(v0: List, v1: Bytes) -> List { + List::cons(v1, v0) +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a36 = v0; + let a37 = v1; + index_bytes(a36, a37) +} + +pub fn f9(v0: Bytes) -> Bytes { + if f10(v0.clone(), Bytes::lit(&[0x0d])) { + f4(v0.clone(), 0u64, { + let a39 = { + let a38 = v0; + length_bytes(a38) + }; + let a40 = 1u64; + nat_sub(a39, a40) + }) + } else { + v0 + } +} + +pub fn f10(v0: Bytes, v1: Bytes) -> bool { + let v2: u64 = { + let a41 = v0.clone(); + length_bytes(a41) + }; + let v3: u64 = { + let a42 = v1.clone(); + length_bytes(a42) + }; + let a43 = v3; + let a44 = v2; + if nat_le(a43, a44) { + let m50 = { + let a47 = v0; + let a48 = { + let a45 = v2; + let a46 = v3; + nat_sub(a45, a46) + }; + let a49 = v3; + slice_bytes(a47, a48, a49) + }; + match m50 { + None => { + false + } + Some(v4) => { + let a51 = v4; + let a52 = v1; + equal(a51, a52) + } + } + } else { + false + } +} diff --git a/stdlib/expected/verify/preserve/crate/R5.rust-std.rs b/stdlib/expected/verify/preserve/crate/R5.rust-std.rs new file mode 100644 index 0000000000..e6c00dfff3 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R5.rust-std.rs @@ -0,0 +1,352 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: Option, p1: Bytes) -> Option { + match self { + Fn0::F2(k0) => f2(k0.clone(), p0, p1), + } + } +} + +pub fn f0(v0: List, v1: Bytes) -> Bytes { + let m1 = f1(Fn0::F2(v1), None::, v0); + match m1 { + None => { + Bytes::lit(&[]) + } + Some(v2) => { + v2 + } + } +} + +pub fn f1(v0: Fn0, v1: Option, v2: List) -> Option { + let m2 = v2; + match m2.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f1(v0.clone(), { + let c3: Fn0 = v0; + c3.apply(v1, v3) + }, v4) + } + } +} + +pub fn f2(v0: Bytes, v1: Option, v2: Bytes) -> Option { + let m4 = v1; + match m4 { + None => { + Some(v2) + } + Some(v3) => { + Some({ + let a7 = { + let a5 = v3; + let a6 = v0; + append_bytes(a5, a6) + }; + let a8 = v2; + append_bytes(a7, a8) + }) + } + } +} diff --git a/stdlib/expected/verify/preserve/crate/R6.rust-std.rs b/stdlib/expected/verify/preserve/crate/R6.rust-std.rs new file mode 100644 index 0000000000..1ec6d873f6 --- /dev/null +++ b/stdlib/expected/verify/preserve/crate/R6.rust-std.rs @@ -0,0 +1,394 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes, u64, Bytes, u64), +} + +impl Fn0 { + pub fn apply(&self, p0: u64) -> R> { + match self { + Fn0::F2(k0, k1, k2, k3) => f2(k0.clone(), *k1, k2.clone(), *k3, p0), + } + } +} + +pub fn f0(v0: Bytes, v1: Bytes) -> R> { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: u64 = { + let a2 = v1.clone(); + length_bytes(a2) + }; + let v4: u64 = { + let (h3, _) = f1(Fn0::F2(v1.clone(), v3, v0.clone(), v2), { + let a4 = v2; + let a5 = 1u64; + nat_add(a4, a5)? + }, 0u64)?; + h3 + }; + if f3(v0, v1, v4) { + Ok(Some(v4)) + } else { + Ok(None::) + } +} + +pub fn f1(v0: Fn0, v1: u64, v2: u64) -> R<(u64, bool)> { + let m6 = v1; + if m6 == 0 { + Ok((v2, false)) + } else { + let v3 = m6 - 1; + let m8 = { + let c7: Fn0 = v0.clone(); + c7.apply(v2)? + }; + match m8 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: Bytes, v1: u64, v2: Bytes, v3: u64, v4: u64) -> R> { + if f3(v2, v0, v4) { + Ok(None::) + } else { + let a11 = { + let a9 = v4; + let a10 = v1; + nat_add(a9, a10)? + }; + let a12 = v3; + if nat_lt(a11, a12) { + Ok(Some({ + let a13 = v4; + let a14 = 1u64; + nat_add(a13, a14)? + })) + } else { + Ok(None::) + } + } +} + +pub fn f3(v0: Bytes, v1: Bytes, v2: u64) -> bool { + let m19 = { + let a16 = v0; + let a17 = v2; + let a18 = { + let a15 = v1.clone(); + length_bytes(a15) + }; + slice_bytes(a16, a17, a18) + }; + match m19 { + None => { + false + } + Some(v3) => { + let a20 = v3; + let a21 = v1; + equal(a20, a21) + } + } +} diff --git a/stdlib/expected/verify/preserve/preservation.json b/stdlib/expected/verify/preserve/preservation.json new file mode 100644 index 0000000000..3c6d680a10 --- /dev/null +++ b/stdlib/expected/verify/preserve/preservation.json @@ -0,0 +1 @@ +{"library":{"axioms":["Classical.choice","Quot.sound","propext"],"registry_sha256":"02de6e4be5a6ae43997bacd3713ea587693b8ac66da4aef567463a535a076ff3"},"roots":[{"byte_length":4532,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0","program":{"byte_length":735,"sha256":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f"},"renderings":[{"byte_length":5198,"composed":{"byte_length":13297,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd","sha256":"e64470bb6c330ab798325a665003b05eb30bbbd666d9f79eae4b9641f315a293","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.root"},"crate":{"byte_length":13187,"sha256":"ecbb884548b529d7e84909723ca7a81a4faf337126be517c3cfa81827316dc4f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd","sha256":"c279e924018bf40b145a0cde0c86cb839f6e19cc6c91e0307ea2e5534143a822","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.root"}],"root":"LexLeanStd.Text.startsWith","sha256":"b2e996de8602c877ce9cc1187e8afe968656eb73480472bcd473d28951483c0f","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.root"},{"byte_length":7029,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1","program":{"byte_length":1240,"sha256":"2e8cee85b376065a6078160fa53fd52c7a2f6aa31eb349462fb499ef41683e7f"},"renderings":[{"byte_length":9638,"composed":{"byte_length":13295,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd","sha256":"76cd9e783b47c0549493206f6fbae41264849a1e28d6f270c5ebabb6a08cee6e","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.root"},"crate":{"byte_length":13540,"sha256":"19d453bddf0fcdb46b45f5a3be483fa281f67e29cfd7888fa747dfc44a7350b1"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd","sha256":"e57439d0c528e126f5e5b59f068736ee65afd7094c30fdb6c38b778a4fc8cc55","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.root"}],"root":"LexLeanStd.Text.endsWith","sha256":"19539e056f7a8417bb4d70fb5e6decaacd495fdaef49e07127a19dbc0dc31f8d","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.root"},{"byte_length":31004,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2","program":{"byte_length":7351,"sha256":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455"},"renderings":[{"byte_length":37513,"composed":{"byte_length":12066,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd","sha256":"b64013046455453605cf75d48ed52f17c4be770c336ac66c14ee864f63cadf29","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.root"},"crate":{"byte_length":15976,"sha256":"682968e0ba898d7ddd56862ff4f443cb9918653229002af6c18a4c31df0a007c"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd","sha256":"8d629e258648f0c7c77da1c87846088899aa67c3e3cdd1a73208381266f18445","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.root"}],"root":"LexLeanStd.Text.trim","sha256":"9c455a066dd0ffeca539c9f9d59efc2280367b1ec495d34be3dfe8e40b53a3cd","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.root"},{"byte_length":30155,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3","program":{"byte_length":10335,"sha256":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3"},"renderings":[{"byte_length":41781,"composed":{"byte_length":14062,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd","sha256":"ee8ec85efb3f54781de1529a7652ace08d08f6b29c35c9e63153ef8be3f078c2","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.root"},"crate":{"byte_length":16698,"sha256":"e7f7355f576d9a156f1a77d9659f9a15f11bc2d2764284bdbde923db1853fc6f"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd","sha256":"5ebdd407e6da8375c4fe30666c48e4afe6e860c04372123c6b12b2d7433f6819","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.root"}],"root":"LexLeanStd.Text.splitOn","sha256":"271580289a4537a5e25e3db697e66ba1642f0a24a185b1077b94b887a8b9db5a","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.root"},{"byte_length":40549,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4","program":{"byte_length":12480,"sha256":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea"},"renderings":[{"byte_length":56039,"composed":{"byte_length":12109,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd","sha256":"32f1425cd7d39113c526b90a04f1aa36a29dc9a541c8636d38a838e0db6f2f68","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.root"},"crate":{"byte_length":17906,"sha256":"4ea4e572ad6fca908ee188267f4b1f7ca812087ee75b178dd81932fdc7c99ae9"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd","sha256":"c47412b0d70bdaa41740676d5150034716de52f26a53969a97f6bf76ff917ffe","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.root"}],"root":"LexLeanStd.Text.lines","sha256":"d4e003a807c9b644681a53cb567d34119ad59b92042c330aa718c5c492732a38","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.root"},{"byte_length":9823,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5","program":{"byte_length":2224,"sha256":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a"},"renderings":[{"byte_length":11921,"composed":{"byte_length":14998,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd","sha256":"b954bf0e0e31c1b7b3b8f479ae72da2bef94af4f35c1e6f3a4735eb4775e6aca","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.root"},"crate":{"byte_length":13992,"sha256":"539c1cc369fa726faf19d46f599ba91d3735bb6ce3ae1f6a9154eea8e86ae9a8"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd","sha256":"08d2c31b60e5a441ab3342501317486b299bae90f5ead9709a4d42d60e2a8e09","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.root"}],"root":"LexLeanStd.Text.joinWith","sha256":"3d309b190c3f5929b75b1b6cd6ef36535bdae822a0045a44487c6e606f4945eb","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.root"},{"byte_length":17309,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6","program":{"byte_length":4379,"sha256":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178"},"renderings":[{"byte_length":23324,"composed":{"byte_length":13336,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd","sha256":"6ab6a574d0207397e99e4e201daf3b25aa55805b0039a3570fdaf27c8e3b6ac3","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.root"},"crate":{"byte_length":14897,"sha256":"67e641527ec2d8c918047395e0b99d352b8270a3ef51124149af1a42548661d2"},"entry":{"function":0,"symbol":"f0"},"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd","sha256":"4227ad0b3b65a824f9767bdf3c94c93a2577123f11dfdd0c119f92f9f27d4ee6","target":"rust-std","theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.root"}],"root":"LexLeanStd.Text.find","sha256":"a5b4fd6799a0b6b813bb1df4b19fe1a136483dbea55367a0a6aa64ab2ac0fad5","targets":["rust-std"],"theorem":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.root"}],"spec":"lexlean/preservation/1"} diff --git a/stdlib/expected/verify/preserve/program/R0.json b/stdlib/expected/verify/preserve/program/R0.json new file mode 100644 index 0000000000..188e82a23f --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R0.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R1.json b/stdlib/expected/verify/preserve/program/R1.json new file mode 100644 index 0000000000..051dae0368 --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R1.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R2.json b/stdlib/expected/verify/preserve/program/R2.json new file mode 100644 index 0000000000..60dd1b9d6b --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R2.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R3.json b/stdlib/expected/verify/preserve/program/R3.json new file mode 100644 index 0000000000..7c16957cb0 --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R3.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R4.json b/stdlib/expected/verify/preserve/program/R4.json new file mode 100644 index 0000000000..c46dbc2f63 --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R4.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R5.json b/stdlib/expected/verify/preserve/program/R5.json new file mode 100644 index 0000000000..177e6dd9c7 --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R5.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/preserve/program/R6.json b/stdlib/expected/verify/preserve/program/R6.json new file mode 100644 index 0000000000..6158247e29 --- /dev/null +++ b/stdlib/expected/verify/preserve/program/R6.json @@ -0,0 +1 @@ +{"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"} diff --git a/stdlib/expected/verify/probe/LexLeanProbe.Pb4a41a9b6af3776bed9cd860f1a4f2d9.lean b/stdlib/expected/verify/probe/LexLeanProbe.Pb4a41a9b6af3776bed9cd860f1a4f2d9.lean new file mode 100644 index 0000000000..85a015f424 --- /dev/null +++ b/stdlib/expected/verify/probe/LexLeanProbe.Pb4a41a9b6af3776bed9cd860f1a4f2d9.lean @@ -0,0 +1,2 @@ +module +set_option autoImplicit false diff --git a/stdlib/expected/verify/probe/process.json b/stdlib/expected/verify/probe/process.json new file mode 100644 index 0000000000..202e31310f --- /dev/null +++ b/stdlib/expected/verify/probe/process.json @@ -0,0 +1 @@ +{"argv":["env","lean","$STAGING/probe/LexLeanProbe.Pb4a41a9b6af3776bed9cd860f1a4f2d9.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanProbe.Pb4a41a9b6af3776bed9cd860f1a4f2d9","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/lean/LexLeanRuntime.Collections.json b/stdlib/expected/verify/process/lean/LexLeanRuntime.Collections.json new file mode 100644 index 0000000000..75248f178f --- /dev/null +++ b/stdlib/expected/verify/process/lean/LexLeanRuntime.Collections.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/lean-src","-o","$STAGING/oleans/LexLeanRuntime/Collections.olean","$STAGING/lean-src/LexLeanRuntime/Collections.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/lean/LexLeanRuntime.Portable.json b/stdlib/expected/verify/process/lean/LexLeanRuntime.Portable.json new file mode 100644 index 0000000000..1ce5b3a39d --- /dev/null +++ b/stdlib/expected/verify/process/lean/LexLeanRuntime.Portable.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/lean-src","-o","$STAGING/oleans/LexLeanRuntime/Portable.olean","$STAGING/lean-src/LexLeanRuntime/Portable.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/lean/LexLeanStd.Text.json b/stdlib/expected/verify/process/lean/LexLeanStd.Text.json new file mode 100644 index 0000000000..7183f0d606 --- /dev/null +++ b/stdlib/expected/verify/process/lean/LexLeanStd.Text.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/lean-src","-o","$STAGING/oleans/LexLeanStd/Text.olean","$STAGING/lean-src/LexLeanStd/Text.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanStd.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json new file mode 100644 index 0000000000..40fbcef92f --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json new file mode 100644 index 0000000000..3e18a684bf --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json new file mode 100644 index 0000000000..f237df3b0b --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json new file mode 100644 index 0000000000..fcb3b78708 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json new file mode 100644 index 0000000000..c89e08ce94 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json new file mode 100644 index 0000000000..7e173ebbe2 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json new file mode 100644 index 0000000000..09d591c743 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json new file mode 100644 index 0000000000..0d959f5598 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json new file mode 100644 index 0000000000..ef682e6935 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json new file mode 100644 index 0000000000..d47401aa82 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json new file mode 100644 index 0000000000..acd701d69c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json new file mode 100644 index 0000000000..178329edfb --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json new file mode 100644 index 0000000000..40c2ef2818 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json new file mode 100644 index 0000000000..117b647760 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json new file mode 100644 index 0000000000..ea85b9714c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json new file mode 100644 index 0000000000..b45fcd004e --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json new file mode 100644 index 0000000000..3e2d7dba75 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json new file mode 100644 index 0000000000..6590d3efce --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json new file mode 100644 index 0000000000..6e1a9a4ae6 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json new file mode 100644 index 0000000000..aba0521598 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json new file mode 100644 index 0000000000..2ad512938e --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Collections.json b/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Collections.json new file mode 100644 index 0000000000..52662ef9b3 --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Collections.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanRuntime.Collections"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanRuntime.Collections","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Portable.json b/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Portable.json new file mode 100644 index 0000000000..826a4b876c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanRuntime.Portable.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanRuntime.Portable"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanRuntime.Portable","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/leanchecker/LexLeanStd.Text.json b/stdlib/expected/verify/process/leanchecker/LexLeanStd.Text.json new file mode 100644 index 0000000000..f06c0b412c --- /dev/null +++ b/stdlib/expected/verify/process/leanchecker/LexLeanStd.Text.json @@ -0,0 +1 @@ +{"argv":["env","$TOOLCHAIN/bin/leanchecker","LexLeanStd.Text"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanStd.Text","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"leanchecker"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Compose.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Compose.json new file mode 100644 index 0000000000..76f636d3ae --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Compose.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Compose.olean","$STAGING/preserve-src/LexLeanPreservation/Compose.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Compose","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Core.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Core.json new file mode 100644 index 0000000000..8a44ff1b8e --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Core.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Core.olean","$STAGING/preserve-src/LexLeanPreservation/Core.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Core","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Fixed.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Fixed.json new file mode 100644 index 0000000000..5ee634136f --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Fixed.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Fixed.olean","$STAGING/preserve-src/LexLeanPreservation/Fixed.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Fixed","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Keys.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Keys.json new file mode 100644 index 0000000000..936ce76ce8 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Keys.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Keys.olean","$STAGING/preserve-src/LexLeanPreservation/Keys.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Keys","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Primitives.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Primitives.json new file mode 100644 index 0000000000..b461c3f864 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Primitives.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Primitives.olean","$STAGING/preserve-src/LexLeanPreservation/Primitives.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Primitives","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustBase.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustBase.json new file mode 100644 index 0000000000..8ac0a8ca54 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustBase.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/RustBase.olean","$STAGING/preserve-src/LexLeanPreservation/RustBase.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.RustBase","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustCorr.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustCorr.json new file mode 100644 index 0000000000..9e074d3dfd --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustCorr.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/RustCorr.olean","$STAGING/preserve-src/LexLeanPreservation/RustCorr.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.RustCorr","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustLemmas.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustLemmas.json new file mode 100644 index 0000000000..6adf40941a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustLemmas.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/RustLemmas.olean","$STAGING/preserve-src/LexLeanPreservation/RustLemmas.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.RustLemmas","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustMatches.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustMatches.json new file mode 100644 index 0000000000..07c923b808 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustMatches.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/RustMatches.olean","$STAGING/preserve-src/LexLeanPreservation/RustMatches.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.RustMatches","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustSound.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustSound.json new file mode 100644 index 0000000000..58cbadea7e --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.RustSound.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/RustSound.olean","$STAGING/preserve-src/LexLeanPreservation/RustSound.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.RustSound","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Templates.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Templates.json new file mode 100644 index 0000000000..af94954acb --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Templates.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Templates.olean","$STAGING/preserve-src/LexLeanPreservation/Templates.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Templates","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Validate.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Validate.json new file mode 100644 index 0000000000..62727920f2 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Validate.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Validate.olean","$STAGING/preserve-src/LexLeanPreservation/Validate.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Validate","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreservation.Values.json b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Values.json new file mode 100644 index 0000000000..21cb2fc893 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreservation.Values.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreservation/Values.olean","$STAGING/preserve-src/LexLeanPreservation/Values.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreservation.Values","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json new file mode 100644 index 0000000000..e1a7bcff71 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Audit.json @@ -0,0 +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.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.root' depends on axioms: [propext, Classical.choice, Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.root' depends on axioms: [propext,\n Classical.choice,\n Quot.sound]\n'LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.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":"747506612f485adb002762a0d1c2d6f3b96b2e7d9e9240e82260f349a2f9d8fd","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json new file mode 100644 index 0000000000..457e18173a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json new file mode 100644 index 0000000000..d601487b26 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json new file mode 100644 index 0000000000..31406bae41 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R0.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R0","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json new file mode 100644 index 0000000000..3bab05e50a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json new file mode 100644 index 0000000000..e9ab52d306 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json new file mode 100644 index 0000000000..2e234072e4 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R1.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R1","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json new file mode 100644 index 0000000000..07cc5503ce --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json new file mode 100644 index 0000000000..bebb854a55 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json new file mode 100644 index 0000000000..2bb69181c1 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R2.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R2","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json new file mode 100644 index 0000000000..68a082a3af --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json new file mode 100644 index 0000000000..822ccb9c81 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json new file mode 100644 index 0000000000..f678fc0549 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R3.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R3","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json new file mode 100644 index 0000000000..82cc915b77 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json new file mode 100644 index 0000000000..61fed03c58 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json new file mode 100644 index 0000000000..a8ac600fd6 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R4.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R4","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json new file mode 100644 index 0000000000..15467ef12b --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json new file mode 100644 index 0000000000..47150719b7 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json new file mode 100644 index 0000000000..3786404d4f --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R5.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R5","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json new file mode 100644 index 0000000000..da8ca3c54e --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/Compose/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/Compose/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.Compose.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json new file mode 100644 index 0000000000..b02fbc028f --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/RustStd.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6/RustStd.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.RustStd","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json new file mode 100644 index 0000000000..328835a606 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6.olean","$STAGING/preserve-src/LexLeanPreserve/Cb4a41a9b6af3776bed9cd860f1a4f2d9/R6.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanPreserve.Cb4a41a9b6af3776bed9cd860f1a4f2d9.R6","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSemantics.json b/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSemantics.json new file mode 100644 index 0000000000..e31c876085 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSemantics.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanTarget/RustSemantics.olean","$STAGING/preserve-src/LexLeanTarget/RustSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanTarget.RustSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSyntax.json b/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSyntax.json new file mode 100644 index 0000000000..fc1bcc4c82 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanTarget.RustSyntax.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanTarget/RustSyntax.olean","$STAGING/preserve-src/LexLeanTarget/RustSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanTarget.RustSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSemantics.json b/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSemantics.json new file mode 100644 index 0000000000..49c60249a5 --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSemantics.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanTarget/TargetSemantics.olean","$STAGING/preserve-src/LexLeanTarget/TargetSemantics.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanTarget.TargetSemantics","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSyntax.json b/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSyntax.json new file mode 100644 index 0000000000..8030da609a --- /dev/null +++ b/stdlib/expected/verify/process/preserve/LexLeanTarget.TargetSyntax.json @@ -0,0 +1 @@ +{"argv":["env","lean","-R","$STAGING/preserve-src","-o","$STAGING/preserve-oleans/LexLeanTarget/TargetSyntax.olean","$STAGING/preserve-src/LexLeanTarget/TargetSyntax.lean"],"executable_sha256":"$EXECUTABLE_SHA256","exit_code":0,"module":"LexLeanTarget.TargetSyntax","stderr":"\n","stderr_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","stdout":"\n","stdout_sha256":"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b","tool":"lean"} diff --git a/stdlib/expected/verify/production/compiler-input.json b/stdlib/expected/verify/production/compiler-input.json new file mode 100644 index 0000000000..1d882dad1f --- /dev/null +++ b/stdlib/expected/verify/production/compiler-input.json @@ -0,0 +1 @@ +{"closures":[{"declarations":["LexLeanStd.Text.endsWith"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.endsWith","instance":"LexLeanStd.Text.endsWith","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.endsWith","runtime":["LexLeanRuntime.equal","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice","LexLeanRuntime.subtract"]},{"declarations":["LexLeanStd.Text.find","LexLeanStd.Text.matchAt"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.find","instance":"LexLeanStd.Text.find","type_arguments":[]},{"declaration":"LexLeanStd.Text.matchAt","instance":"LexLeanStd.Text.matchAt","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.find","runtime":["LexLeanCollections.iterateUntil","LexLeanRuntime.equal","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice"]},{"declarations":["LexLeanStd.Text.joinWith"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.joinWith","instance":"LexLeanStd.Text.joinWith","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.joinWith","runtime":["LexLeanCollections.listFold","LexLeanRuntime.append","LexLeanRuntime.instAppendableByteArray"]},{"declarations":["LexLeanStd.Text.byteAt","LexLeanStd.Text.chomp","LexLeanStd.Text.endsWith","LexLeanStd.Text.lineStep","LexLeanStd.Text.lines","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.lines","instance":"LexLeanStd.Text.lines","type_arguments":[]},{"declaration":"LexLeanStd.Text.lineStep","instance":"LexLeanStd.Text.lineStep","type_arguments":[]},{"declaration":"LexLeanStd.Text.reverse","instance":"LexLeanStd.Text.reverse","type_arguments":[]},{"declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","type_arguments":[]},{"declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","type_arguments":[]},{"declaration":"LexLeanStd.Text.chomp","instance":"LexLeanStd.Text.chomp","type_arguments":[]},{"declaration":"LexLeanStd.Text.endsWith","instance":"LexLeanStd.Text.endsWith","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.lines","runtime":["LexLeanCollections.iterateUntil","LexLeanCollections.listFold","LexLeanRuntime.equal","LexLeanRuntime.index","LexLeanRuntime.instIndexableByteArrayUInt8","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice","LexLeanRuntime.subtract"]},{"declarations":["LexLeanStd.Text.byteAt","LexLeanStd.Text.reverse","LexLeanStd.Text.sliceOr","LexLeanStd.Text.splitOn","LexLeanStd.Text.splitStep"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.splitOn","instance":"LexLeanStd.Text.splitOn","type_arguments":[]},{"declaration":"LexLeanStd.Text.splitStep","instance":"LexLeanStd.Text.splitStep","type_arguments":[]},{"declaration":"LexLeanStd.Text.reverse","instance":"LexLeanStd.Text.reverse","type_arguments":[]},{"declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","type_arguments":[]},{"declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.splitOn","runtime":["LexLeanCollections.iterateUntil","LexLeanCollections.listFold","LexLeanRuntime.equal","LexLeanRuntime.index","LexLeanRuntime.instIndexableByteArrayUInt8","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice","LexLeanRuntime.subtract"]},{"declarations":["LexLeanStd.Text.startsWith"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.startsWith","instance":"LexLeanStd.Text.startsWith","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.startsWith","runtime":["LexLeanRuntime.equal","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice"]},{"declarations":["LexLeanStd.Text.byteAt","LexLeanStd.Text.isSpace","LexLeanStd.Text.sliceOr","LexLeanStd.Text.spaceAt","LexLeanStd.Text.trim","LexLeanStd.Text.trimEnd","LexLeanStd.Text.trimStart"],"erased":[],"instances":[{"declaration":"LexLeanStd.Text.trim","instance":"LexLeanStd.Text.trim","type_arguments":[]},{"declaration":"LexLeanStd.Text.trimEnd","instance":"LexLeanStd.Text.trimEnd","type_arguments":[]},{"declaration":"LexLeanStd.Text.trimStart","instance":"LexLeanStd.Text.trimStart","type_arguments":[]},{"declaration":"LexLeanStd.Text.sliceOr","instance":"LexLeanStd.Text.sliceOr","type_arguments":[]},{"declaration":"LexLeanStd.Text.spaceAt","instance":"LexLeanStd.Text.spaceAt","type_arguments":[]},{"declaration":"LexLeanStd.Text.byteAt","instance":"LexLeanStd.Text.byteAt","type_arguments":[]},{"declaration":"LexLeanStd.Text.isSpace","instance":"LexLeanStd.Text.isSpace","type_arguments":[]}],"internal_erased":[],"root":"LexLeanStd.Text.trim","runtime":["LexLeanCollections.iterateUntil","LexLeanRuntime.equal","LexLeanRuntime.index","LexLeanRuntime.instIndexableByteArrayUInt8","LexLeanRuntime.instLengthableByteArray","LexLeanRuntime.instSliceableByteArray","LexLeanRuntime.length","LexLeanRuntime.slice","LexLeanRuntime.subtract"]}],"declarations":[{"code":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v27","kind":"return"},"id":"v27","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"id":"v3","kind":"fvar"}],"function":"v8","kind":"apply"}},"constructor":"Nat.zero","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v29","kind":"return"},"id":"v29","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"id":"v28","kind":"fvar"},{"id":"v3","kind":"fvar"}],"function":"v26","kind":"apply"}},"constructor":"Nat.succ","kind":"constructor","parameters":[{"borrow":false,"id":"v28","type":{"kind":"const","levels":[],"name":"Nat"}}]}],"discriminant":"v2","kind":"cases","result_type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"type_name":"Nat"},"id":"v26","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"arguments":[],"function":"v9","kind":"apply"}},"declaration":{"id":"v9","parameters":[{"borrow":false,"id":"v10","type":{"kind":"const","levels":[],"name":"Nat"}},{"borrow":false,"id":"v11","type":{"id":"v0","kind":"fvar"}}],"type":{"codomain":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v23","kind":"return"},"id":"v23","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"id":"v22","kind":"fvar"}],"function":"v16","kind":"apply"}},"id":"v22","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v25","kind":"return"},"id":"v25","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"id":"v24","kind":"fvar"}],"function":"v20","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v24","type":{"id":"v0","kind":"fvar"}}]}],"discriminant":"v21","kind":"cases","result_type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"type_name":"Option"},"id":"v21","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v11","kind":"fvar"}],"function":"v1","kind":"apply"}},"id":"v20","kind":"let","type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"arguments":[],"function":"v17","kind":"apply"}},"declaration":{"id":"v17","parameters":[{"borrow":false,"id":"v18","type":{"id":"v0","kind":"fvar"}}],"type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"body":{"id":"v19","kind":"return"},"id":"v19","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"id":"v0","kind":"fvar"}},{"id":"v1","kind":"fvar"},{"id":"v10","kind":"fvar"},{"id":"v18","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}}},"kind":"fun"},"id":"v16","kind":"let","type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v12","kind":"apply"}},"declaration":{"id":"v12","parameters":[{"borrow":false,"id":"v13","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"id":"v15","kind":"return"},"id":"v15","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"id":"v0","kind":"fvar"}},{"kind":"type","type":{"kind":"const","levels":[],"name":"Bool"}},{"id":"v11","kind":"fvar"},{"id":"v14","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}}},"kind":"fun"}},"kind":"fun"},"id":"v8","kind":"let","type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"arguments":[],"function":"v4","kind":"apply"}},"declaration":{"id":"v4","parameters":[{"borrow":false,"id":"v5","type":{"id":"v0","kind":"fvar"}}],"type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"body":{"body":{"id":"v7","kind":"return"},"id":"v7","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"id":"v0","kind":"fvar"}},{"kind":"type","type":{"kind":"const","levels":[],"name":"Bool"}},{"id":"v5","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanCollections.iterateUntil","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"}},{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}},{"borrow":false,"id":"v3","type":{"id":"v0","kind":"fvar"}}],"recursive":true,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"arguments":[{"index":3,"kind":"bvar"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"codomain":{"arguments":[{"index":1,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"index":0,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"id":"v5","kind":"return"},"id":"v5","kind":"let","type":{"id":"v1","kind":"fvar"},"value":{"arguments":[{"kind":"type","type":{"id":"v1","kind":"fvar"}},{"kind":"type","type":{"id":"v0","kind":"fvar"}},{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"List.foldl"}},"level_parameters":[],"name":"LexLeanCollections.listFold","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v2","type":{"codomain":{"codomain":{"id":"v1","kind":"fvar"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"id":"v1","kind":"fvar"},"kind":"arrow"}},{"borrow":false,"id":"v3","type":{"id":"v1","kind":"fvar"}},{"borrow":false,"id":"v4","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"codomain":{"index":3,"kind":"bvar"},"domain":{"arguments":[{"index":3,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"codomain":{"codomain":{"index":2,"kind":"bvar"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"index":0,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v5","kind":"return"},"id":"v5","kind":"let","type":{"id":"v0","kind":"fvar"},"value":{"arguments":[{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"}],"function":"v4","kind":"apply"}},"id":"v4","kind":"let","type":{"codomain":{"codomain":{"id":"v0","kind":"fvar"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"LexLeanRuntime.Appendable","value":"v1"}},"level_parameters":[],"name":"LexLeanRuntime.append","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"}},{"borrow":false,"id":"v2","type":{"id":"v0","kind":"fvar"}},{"borrow":false,"id":"v3","type":{"id":"v0","kind":"fvar"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"index":3,"kind":"bvar"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v5","kind":"return"},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"}],"function":"v4","kind":"apply"}},"id":"v4","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"BEq","value":"v1"}},"level_parameters":[],"name":"LexLeanRuntime.equal","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"}},{"borrow":false,"id":"v2","type":{"id":"v0","kind":"fvar"}},{"borrow":false,"id":"v3","type":{"id":"v0","kind":"fvar"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"arguments":[{"id":"v1","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v3","kind":"fvar"},{"id":"v4","kind":"fvar"}],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"id":"v1","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"LexLeanRuntime.Indexable","value":"v2"}},"level_parameters":[],"name":"LexLeanRuntime.index","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v2","type":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"}},{"borrow":false,"id":"v3","type":{"id":"v0","kind":"fvar"}},{"borrow":false,"id":"v4","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"codomain":{"arguments":[{"index":3,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":1,"kind":"bvar"},{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v1","kind":"return"},"id":"v1","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable.mk"}},"id":"v0","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"ByteArray.fastAppend"}},"level_parameters":[],"name":"LexLeanRuntime.instAppendableByteArray","parameters":[],"recursive":false,"type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"}},{"code":{"body":{"body":{"id":"v7","kind":"return"},"id":"v7","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"},{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable.mk"}},"declaration":{"id":"v0","parameters":[{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}}],"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v5","kind":"fvar"},{"id":"v2","kind":"fvar"}],"function":"v4","kind":"apply"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},"value":{"arguments":[{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.data"}},"id":"v4","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},"kind":"arrow"},"value":{"index":1,"kind":"projection","type_name":"GetElem?","value":"v3"}},"id":"v3","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"UInt8"},{"kind":"erased"}],"head":{"kind":"const","levels":["0","0","0"],"name":"GetElem?"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}}],"kind":"const","levels":["0"],"name":"Array.instGetElem?NatLtSize"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanRuntime.instIndexableByteArrayUInt8","parameters":[],"recursive":false,"type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"},{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"}},{"code":{"body":{"body":{"id":"v1","kind":"return"},"id":"v1","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable.mk"}},"id":"v0","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"ByteArray.size"}},"level_parameters":[],"name":"LexLeanRuntime.instLengthableByteArray","parameters":[],"recursive":false,"type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"}},{"code":{"body":{"body":{"id":"v15","kind":"return"},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable.mk"}},"declaration":{"id":"v0","parameters":[{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}},{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"Nat"}}],"type":{"codomain":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v11","kind":"return"},"id":"v11","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v10","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"id":"v14","kind":"return"},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v13","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v13","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v1","kind":"fvar"},{"id":"v2","kind":"fvar"},{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.extract"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v12","type":{"kind":"erased"}}]}],"discriminant":"v9","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v9","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v7","kind":"fvar"},{"id":"v8","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.decLe"}},"id":"v8","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.size"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"}],"function":"v6","kind":"apply"}},"id":"v6","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v5"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v4","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanRuntime.instSliceableByteArray","parameters":[],"recursive":false,"type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"}},{"code":{"body":{"body":{"id":"v4","kind":"return"},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v2","kind":"fvar"}],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"LexLeanRuntime.Lengthable","value":"v1"}},"level_parameters":[],"name":"LexLeanRuntime.length","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"}},{"borrow":false,"id":"v2","type":{"id":"v0","kind":"fvar"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v4","kind":"fvar"}],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"codomain":{"codomain":{"codomain":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"LexLeanRuntime.Sliceable","value":"v1"}},"level_parameters":[],"name":"LexLeanRuntime.slice","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"}},{"borrow":false,"id":"v2","type":{"id":"v0","kind":"fvar"}},{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"Nat"}},{"borrow":false,"id":"v4","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"codomain":{"arguments":[{"index":4,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"id":"v0","kind":"fvar"},"value":{"arguments":[{"id":"v2","kind":"fvar"},{"id":"v3","kind":"fvar"}],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"codomain":{"codomain":{"id":"v0","kind":"fvar"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"domain":{"id":"v0","kind":"fvar"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HSub","value":"v4"}},"id":"v4","kind":"let","type":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HSub"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"id":"v0","kind":"fvar"}},{"id":"v1","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHSub"}},"level_parameters":[],"name":"LexLeanRuntime.subtract","parameters":[{"borrow":false,"id":"v0","type":{"kind":"sort","level":"1"}},{"borrow":false,"id":"v1","type":{"arguments":[{"id":"v0","kind":"fvar"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"}},{"borrow":false,"id":"v2","type":{"id":"v0","kind":"fvar"}},{"borrow":false,"id":"v3","type":{"id":"v0","kind":"fvar"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"codomain":{"index":3,"kind":"bvar"},"domain":{"index":2,"kind":"bvar"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"arguments":[{"index":0,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}},{"code":{"body":{"body":{"id":"v3","kind":"return"},"id":"v3","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v2","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.index"}},"id":"v2","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"},{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instIndexableByteArrayUInt8"}},"level_parameters":[],"name":"LexLeanStd.Text.byteAt","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"id":"v0","kind":"return"},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v11","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v23","kind":"return"},"id":"v23","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v15","kind":"fvar"},{"id":"v22","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v16","kind":"fvar"},{"id":"v18","kind":"fvar"},{"id":"v21","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v20"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v19","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v19","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v18","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v17","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v17","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"id":"v16","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v14"}},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v13","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v13","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v12","type":{"kind":"erased"}}]}],"discriminant":"v10","kind":"cases","result_type":{"kind":"const","levels":[],"name":"ByteArray"},"type_name":"Decidable"},"id":"v10","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v8","kind":"fvar"},{"id":"v9","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v9","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v8","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.endsWith"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.mk"}},"id":"v6","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v5","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.toArray"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v3","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}}],"kind":"const","levels":["0"],"name":"List.nil"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v2"}},"id":"v2","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v1","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"13"}}},"level_parameters":[],"name":"LexLeanStd.Text.chomp","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v11","kind":"return"},"id":"v11","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v10","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v27","kind":"return"},"id":"v27","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v26","kind":"fvar"}],"function":"v21","kind":"apply"}},"id":"v26","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v29","kind":"return"},"id":"v29","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v28","kind":"fvar"}],"function":"v17","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v28","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v25","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Option"},"id":"v25","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v22","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v24","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.slice"}},"id":"v24","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v23","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v23","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v22","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instSliceableByteArray"}},"id":"v21","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v18","kind":"apply"}},"declaration":{"id":"v18","parameters":[{"borrow":false,"id":"v19","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v20","kind":"return"},"id":"v20","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}}},"kind":"fun"},"id":"v17","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v13","kind":"apply"}},"declaration":{"id":"v13","parameters":[{"borrow":false,"id":"v14","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"id":"v16","kind":"return"},"id":"v16","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v15","kind":"fvar"},{"id":"v14","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"ByteArray.instBEq"}}},"kind":"fun"},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v12","type":{"kind":"erased"}}]}],"discriminant":"v9","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Decidable"},"id":"v9","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v7","kind":"fvar"},{"id":"v8","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v8","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v6","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.ble"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v2","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v2","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v2","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"level_parameters":[],"name":"LexLeanStd.Text.endsWith","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v46","kind":"return"},"id":"v46","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v45","type":{"kind":"erased"}}]},{"code":{"body":{"id":"v48","kind":"return"},"id":"v48","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v41","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v47","type":{"kind":"erased"}}]}],"discriminant":"v44","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v44","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v42","kind":"fvar"},{"id":"v43","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v43","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v42","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"},{"id":"v41","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.matchAt"}},"id":"v41","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v40","kind":"apply"}},"id":"v40","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v39"}},"id":"v39","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v7","kind":"fvar"},{"id":"v35","kind":"fvar"},{"id":"v38","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}},"id":"v38","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v37"}},"id":"v37","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v36","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v36","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"id":"v35","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v4","kind":"fvar"},{"id":"v34","kind":"fvar"}],"function":"v31","kind":"apply"}},"id":"v34","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v33"}},"id":"v33","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v32","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v32","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v31","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v30"}},"id":"v30","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v29","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v29","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"declaration":{"id":"v7","parameters":[{"borrow":false,"id":"v8","type":{"kind":"const","levels":[],"name":"Nat"}}],"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v20","kind":"return"},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v19","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"id":"v26","kind":"return"},"id":"v26","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v25","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v25","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v8","kind":"fvar"},{"id":"v24","kind":"fvar"}],"function":"v15","kind":"apply"}},"id":"v24","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v23"}},"id":"v23","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v22","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v21","type":{"kind":"erased"}}]}],"discriminant":"v18","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v18","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v17","kind":"fvar"},{"id":"v10","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v16","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.blt"}},"id":"v16","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v8","kind":"fvar"},{"id":"v6","kind":"fvar"}],"function":"v15","kind":"apply"}},"id":"v15","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v14"}},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v13","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v12","type":{"kind":"erased"}}]},{"code":{"body":{"id":"v28","kind":"return"},"id":"v28","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v27","type":{"kind":"erased"}}]}],"discriminant":"v11","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v11","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v9","kind":"fvar"},{"id":"v10","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v10","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v9","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"},{"id":"v8","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.matchAt"}}},"kind":"fun"},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v2","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v2","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v2","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"level_parameters":[],"name":"LexLeanStd.Text.find","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"arguments":[{"id":"v76","kind":"fvar"}],"kind":"jump","target":"v70"},"id":"v76","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.false","kind":"constructor","parameters":[]},{"code":{"body":{"arguments":[{"id":"v77","kind":"fvar"}],"kind":"jump","target":"v73"},"id":"v77","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.true","kind":"constructor","parameters":[]}],"discriminant":"v53","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Bool"},"declaration":{"id":"v73","parameters":[{"borrow":false,"id":"v74","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"arguments":[{"id":"v75","kind":"fvar"}],"kind":"jump","target":"v54"},"id":"v75","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v74","kind":"fvar"}],"function":"v38","kind":"apply"}}},"kind":"join"},"declaration":{"id":"v70","parameters":[{"borrow":false,"id":"v71","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"arguments":[{"id":"v72","kind":"fvar"}],"kind":"jump","target":"v54"},"id":"v72","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v71","kind":"fvar"}],"function":"v47","kind":"apply"}}},"kind":"join"},"declaration":{"id":"v54","parameters":[{"borrow":false,"id":"v55","type":{"kind":"const","levels":[],"name":"Bool"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"Bool"},"kind":"arrow"},"value":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"arguments":[{"id":"v68","kind":"fvar"}],"kind":"jump","target":"v62"},"id":"v68","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.false","kind":"constructor","parameters":[]},{"code":{"body":{"arguments":[{"id":"v69","kind":"fvar"}],"kind":"jump","target":"v65"},"id":"v69","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.true","kind":"constructor","parameters":[]}],"discriminant":"v55","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Bool"},"declaration":{"id":"v65","parameters":[{"borrow":false,"id":"v66","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"arguments":[{"id":"v67","kind":"fvar"}],"kind":"jump","target":"v56"},"id":"v67","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v66","kind":"fvar"}],"function":"v28","kind":"apply"}}},"kind":"join"},"declaration":{"id":"v62","parameters":[{"borrow":false,"id":"v63","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"arguments":[{"id":"v64","kind":"fvar"}],"kind":"jump","target":"v56"},"id":"v64","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v63","kind":"fvar"}],"function":"v37","kind":"apply"}}},"kind":"join"},"declaration":{"id":"v56","parameters":[{"borrow":false,"id":"v57","type":{"kind":"const","levels":[],"name":"Bool"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"Bool"},"kind":"arrow"},"value":{"alternatives":[{"code":{"body":{"body":{"id":"v59","kind":"return"},"id":"v59","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v58","kind":"fvar"}],"function":"v27","kind":"apply"}},"id":"v58","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.false","kind":"constructor","parameters":[]},{"code":{"body":{"body":{"id":"v61","kind":"return"},"id":"v61","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v60","kind":"fvar"}],"function":"v4","kind":"apply"}},"id":"v60","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.true","kind":"constructor","parameters":[]}],"discriminant":"v57","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Bool"}},"kind":"join"}},"kind":"join"},"id":"v53","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v49","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v52","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v52","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v51"}},"id":"v51","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v50","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v50","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"32"}}},"id":"v49","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v48","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v48","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}},"id":"v47","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v39","kind":"apply"}},"declaration":{"id":"v39","parameters":[{"borrow":false,"id":"v40","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v46","kind":"return"},"id":"v46","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v42","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v45","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v45","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v44"}},"id":"v44","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v43","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v43","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"9"}}},"id":"v42","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v41","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v41","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}}},"kind":"fun"},"id":"v38","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v1","kind":"apply"}},"id":"v37","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v29","kind":"apply"}},"declaration":{"id":"v29","parameters":[{"borrow":false,"id":"v30","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v36","kind":"return"},"id":"v36","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v32","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v35","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v35","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v34"}},"id":"v34","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v33","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v33","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"10"}}},"id":"v32","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v31","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v31","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}}},"kind":"fun"},"id":"v28","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v1","kind":"apply"}},"id":"v27","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v5","kind":"apply"}},"declaration":{"id":"v5","parameters":[{"borrow":false,"id":"v6","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v24","kind":"return"},"id":"v24","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v23","kind":"fvar"}],"function":"v16","kind":"apply"}},"id":"v23","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.false","kind":"constructor","parameters":[]},{"code":{"body":{"body":{"id":"v26","kind":"return"},"id":"v26","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v25","kind":"fvar"}],"function":"v7","kind":"apply"}},"id":"v25","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Bool.true","kind":"constructor","parameters":[]}],"discriminant":"v22","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Bool"},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v18","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v21","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v20"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v19","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v19","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"12"}}},"id":"v18","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v17","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v17","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}},"id":"v16","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v8","kind":"apply"}},"declaration":{"id":"v8","parameters":[{"borrow":false,"id":"v9","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v15","kind":"return"},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v11","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v14","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v13"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v12","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v12","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"13"}}},"id":"v11","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v10","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v10","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}}},"kind":"fun"},"id":"v7","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v1","kind":"apply"}}},"kind":"fun"},"id":"v4","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v1","kind":"apply"}},"declaration":{"id":"v1","parameters":[{"borrow":false,"id":"v2","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v3","kind":"return"},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.isSpace","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"UInt8"}}],"recursive":false,"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v32","kind":"return"},"id":"v32","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v31","kind":"fvar"}],"function":"v10","kind":"apply"}},"id":"v31","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v34","kind":"return"},"id":"v34","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v33","kind":"fvar"}],"function":"v4","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v33","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v30","kind":"cases","result_type":{"kind":"const","levels":[],"name":"ByteArray"},"type_name":"Option"},"id":"v30","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"}},{"id":"v11","kind":"fvar"},{"id":"v29","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.listFold"}},"id":"v29","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"declaration":{"id":"v11","parameters":[{"borrow":false,"id":"v12","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"}},{"borrow":false,"id":"v13","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v26","kind":"return"},"id":"v26","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v25","kind":"fvar"}],"function":"v17","kind":"apply"}},"id":"v25","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v28","kind":"return"},"id":"v28","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v27","kind":"fvar"}],"function":"v24","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v27","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v12","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Option"},"id":"v24","kind":"let","type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v18","kind":"apply"}},"declaration":{"id":"v18","parameters":[{"borrow":false,"id":"v19","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"id":"v23","kind":"return"},"id":"v23","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v22","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v20","kind":"fvar"},{"id":"v21","kind":"fvar"},{"id":"v13","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.append"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v20","kind":"fvar"},{"id":"v19","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.append"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instAppendableByteArray"}}},"kind":"fun"},"id":"v17","kind":"let","type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v14","kind":"apply"}},"declaration":{"id":"v14","parameters":[{"borrow":false,"id":"v15","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v16","kind":"return"},"id":"v16","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v13","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}}},"kind":"fun"}},"kind":"fun"},"id":"v10","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v5","kind":"apply"}},"declaration":{"id":"v5","parameters":[{"borrow":false,"id":"v6","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"id":"v9","kind":"return"},"id":"v9","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v8","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.mk"}},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v7","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.toArray"}},"id":"v7","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}}],"kind":"const","levels":["0"],"name":"List.nil"}}},"kind":"fun"},"id":"v4","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v2","kind":"apply"}},"declaration":{"id":"v2","parameters":[{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"id":"v3","kind":"return"}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.joinWith","parameters":[{"borrow":false,"id":"v0","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v53","kind":"return"},"id":"v53","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v52","kind":"fvar"}],"function":"v50","kind":"apply"}},"id":"v52","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v55","kind":"return"},"id":"v55","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v54","kind":"fvar"}],"function":"v46","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v54","type":{"kind":"const","levels":[],"name":"UInt8"}}]}],"discriminant":"v51","kind":"cases","result_type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Option"},"id":"v51","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v3","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.byteAt"}},"id":"v50","kind":"let","type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v47","kind":"apply"}},"declaration":{"id":"v47","parameters":[{"borrow":false,"id":"v48","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v49","kind":"return"},"id":"v49","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"kind":"const","levels":["0"],"name":"Option.none"}}},"kind":"fun"},"id":"v46","kind":"let","type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"function":"v9","kind":"apply"}},"declaration":{"id":"v9","parameters":[{"borrow":false,"id":"v10","type":{"kind":"const","levels":[],"name":"UInt8"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v29","kind":"return"},"id":"v29","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v28","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v28","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v26","kind":"fvar"},{"id":"v27","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v27","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v6","kind":"fvar"},{"id":"v8","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v26","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v3","kind":"fvar"},{"id":"v25","kind":"fvar"}],"function":"v22","kind":"apply"}},"id":"v25","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v24"}},"id":"v24","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v23","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v23","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v22","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v21"}},"id":"v21","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v20","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v19","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v45","kind":"return"},"id":"v45","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v44","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v44","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v37","kind":"fvar"},{"id":"v43","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v43","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v37","kind":"fvar"},{"id":"v42","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v42","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v41","kind":"fvar"},{"id":"v8","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}},"id":"v41","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v40","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.chomp"}},"id":"v40","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v6","kind":"fvar"},{"id":"v39","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v39","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v38","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v38","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v37","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v3","kind":"fvar"},{"id":"v36","kind":"fvar"}],"function":"v33","kind":"apply"}},"id":"v36","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v35"}},"id":"v35","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v34","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v34","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v33","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v32"}},"id":"v32","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v31","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v31","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v30","type":{"kind":"erased"}}]}],"discriminant":"v18","kind":"cases","result_type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v18","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v16","kind":"fvar"},{"id":"v17","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v16","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v12","kind":"fvar"},{"id":"v10","kind":"fvar"},{"id":"v15","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"UInt8"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v14"}},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v13","kind":"fvar"}],"kind":"const","levels":[],"name":"UInt8.instOfNat"}},"id":"v13","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"10"}}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v11","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v11","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}}},"kind":"fun"},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[],"function":"v7","kind":"apply"}},"id":"v7","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v4"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v5","kind":"apply"}},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v4"}},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v1"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v2","kind":"apply"}},"id":"v2","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v1"}},"level_parameters":[],"name":"LexLeanStd.Text.lineStep","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"recursive":false,"type":{"codomain":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v25","kind":"return"},"id":"v25","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"id":"v20","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.reverse"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v24","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"id":"v31","kind":"return"},"id":"v31","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"id":"v30","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.reverse"}},"id":"v30","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v29","kind":"fvar"},{"id":"v20","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}},"id":"v29","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v18","kind":"fvar"},{"id":"v28","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v28","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v27","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v18","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v27","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v26","type":{"kind":"erased"}}]}],"discriminant":"v23","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"type_name":"Decidable"},"id":"v23","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v21","kind":"fvar"},{"id":"v22","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v18","kind":"fvar"},{"id":"v3","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.blt"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[],"function":"v19","kind":"apply"}},"id":"v19","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v16"}},"id":"v18","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v17","kind":"apply"}},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v16"}},"id":"v16","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v15"}},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[],"function":"v14","kind":"apply"}},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v13"}},"id":"v13","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v4","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v12","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v9","kind":"fvar"},{"id":"v11","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v11","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v9","kind":"fvar"},{"id":"v10","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v10","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"kind":"const","levels":["0"],"name":"List.nil"}},"id":"v9","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v8"}},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"declaration":{"id":"v4","parameters":[{"borrow":false,"id":"v5","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"kind":"arrow"},"value":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v5","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.lineStep"}}},"kind":"fun"},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v2","kind":"apply"}},"id":"v2","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v1","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v1","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"level_parameters":[],"name":"LexLeanStd.Text.lines","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v17","kind":"return"},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v16","kind":"fvar"}],"function":"v11","kind":"apply"}},"id":"v16","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v19","kind":"return"},"id":"v19","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v18","kind":"fvar"}],"function":"v7","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v18","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v15","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Option"},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v12","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v2","kind":"fvar"},{"id":"v14","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.slice"}},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v13","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instSliceableByteArray"}},"id":"v11","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v8","kind":"apply"}},"declaration":{"id":"v8","parameters":[{"borrow":false,"id":"v9","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v10","kind":"return"},"id":"v10","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}}},"kind":"fun"},"id":"v7","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"declaration":{"id":"v3","parameters":[{"borrow":false,"id":"v4","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v5","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"ByteArray.instBEq"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.matchAt","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"id":"v6","kind":"return"},"id":"v6","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v1","kind":"fvar"},{"id":"v5","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.listFold"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"kind":"const","levels":["0"],"name":"List.nil"}},"declaration":{"id":"v1","parameters":[{"borrow":false,"id":"v2","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"kind":"arrow"},"value":{"body":{"id":"v4","kind":"return"},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v3","kind":"fvar"},{"id":"v2","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.reverse","parameters":[{"borrow":false,"id":"v0","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}}],"recursive":false,"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v15","kind":"return"},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v14","kind":"fvar"}],"function":"v11","kind":"apply"}},"id":"v14","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v17","kind":"return"},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v16","kind":"fvar"}],"function":"v5","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v16","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v13","kind":"cases","result_type":{"kind":"const","levels":[],"name":"ByteArray"},"type_name":"Option"},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v12","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"},{"id":"v2","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.slice"}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instSliceableByteArray"}},"id":"v11","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v6","kind":"apply"}},"declaration":{"id":"v6","parameters":[{"borrow":false,"id":"v7","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"body":{"body":{"id":"v10","kind":"return"},"id":"v10","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v9","kind":"fvar"}],"kind":"const","levels":[],"name":"ByteArray.mk"}},"id":"v9","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Array"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v8","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.toArray"}},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}}],"kind":"const","levels":["0"],"name":"List.nil"}}},"kind":"fun"},"id":"v5","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"declaration":{"id":"v3","parameters":[{"borrow":false,"id":"v4","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"id":"v4","kind":"return"}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.sliceOr","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"Nat"}},{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v12","kind":"return"},"id":"v12","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v11","kind":"fvar"}],"function":"v9","kind":"apply"}},"id":"v11","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v14","kind":"return"},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v13","kind":"fvar"}],"function":"v5","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v13","type":{"kind":"const","levels":[],"name":"UInt8"}}]}],"discriminant":"v10","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Option"},"id":"v10","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.byteAt"}},"id":"v9","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v6","kind":"apply"}},"declaration":{"id":"v6","parameters":[{"borrow":false,"id":"v7","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v8","kind":"return"},"id":"v8","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}}},"kind":"fun"},"id":"v5","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"function":"v2","kind":"apply"}},"declaration":{"id":"v2","parameters":[{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"UInt8"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"body":{"id":"v4","kind":"return"},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v3","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.isSpace"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.spaceAt","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v25","kind":"return"},"id":"v25","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"id":"v24","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.reverse"}},"id":"v24","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v22","kind":"fvar"},{"id":"v23","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}},"id":"v23","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v17"}},"id":"v22","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v19","kind":"fvar"},{"id":"v21","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v20","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v19","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v19","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v18","kind":"apply"}},"id":"v18","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v17"}},"id":"v17","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v16"}},"id":"v16","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[],"function":"v15","kind":"apply"}},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v14"}},"id":"v14","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v5","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v13","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v10","kind":"fvar"},{"id":"v12","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v10","kind":"fvar"},{"id":"v11","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v11","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"kind":"const","levels":["0"],"name":"List.nil"}},"id":"v10","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v9"}},"id":"v9","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v8","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v8","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"declaration":{"id":"v5","parameters":[{"borrow":false,"id":"v6","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"kind":"arrow"},"value":{"body":{"id":"v7","kind":"return"},"id":"v7","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v1","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.splitStep"}}},"kind":"fun"},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v2","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v2","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"level_parameters":[],"name":"LexLeanStd.Text.splitOn","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"UInt8"}}],"recursive":false,"type":{"codomain":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v50","kind":"return"},"id":"v50","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v49","kind":"fvar"}],"function":"v47","kind":"apply"}},"id":"v49","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v52","kind":"return"},"id":"v52","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v51","kind":"fvar"}],"function":"v43","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v51","type":{"kind":"const","levels":[],"name":"UInt8"}}]}],"discriminant":"v48","kind":"cases","result_type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Option"},"id":"v48","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.byteAt"}},"id":"v47","kind":"let","type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v44","kind":"apply"}},"declaration":{"id":"v44","parameters":[{"borrow":false,"id":"v45","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v46","kind":"return"},"id":"v46","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"kind":"const","levels":["0"],"name":"Option.none"}}},"kind":"fun"},"id":"v43","kind":"let","type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"function":"v10","kind":"apply"}},"declaration":{"id":"v10","parameters":[{"borrow":false,"id":"v11","type":{"kind":"const","levels":[],"name":"UInt8"}}],"type":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v27","kind":"return"},"id":"v27","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v26","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v26","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v24","kind":"fvar"},{"id":"v25","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v25","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v7","kind":"fvar"},{"id":"v9","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v24","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v4","kind":"fvar"},{"id":"v23","kind":"fvar"}],"function":"v20","kind":"apply"}},"id":"v23","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v22"}},"id":"v22","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v21","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v20","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v19"}},"id":"v19","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v18","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v18","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v17","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v42","kind":"return"},"id":"v42","kind":"let","type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v41","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v41","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}},{"id":"v35","kind":"fvar"},{"id":"v40","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v40","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"kind":"type","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}},{"id":"v35","kind":"fvar"},{"id":"v39","kind":"fvar"}],"kind":"const","levels":["0","0"],"name":"Prod.mk"}},"id":"v39","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v38","kind":"fvar"},{"id":"v9","kind":"fvar"}],"kind":"const","levels":["0"],"name":"List.cons"}},"id":"v38","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v7","kind":"fvar"},{"id":"v37","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v37","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v36","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v36","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v35","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v4","kind":"fvar"},{"id":"v34","kind":"fvar"}],"function":"v31","kind":"apply"}},"id":"v34","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v33"}},"id":"v33","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v32","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v32","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v31","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v30"}},"id":"v30","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v29","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v29","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v28","type":{"kind":"erased"}}]}],"discriminant":"v16","kind":"cases","result_type":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v16","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v14","kind":"fvar"},{"id":"v15","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v13","kind":"fvar"},{"id":"v11","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"UInt8"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"UInt8"}},{"id":"v12","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instBEqOfDecidableEq"}},"id":"v12","kind":"let","type":{"codomain":{"codomain":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instDecidableEqUInt8"}}},"kind":"fun"},"id":"v9","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"arguments":[],"function":"v8","kind":"apply"}},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v5"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v6","kind":"apply"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v5"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"index":1,"kind":"projection","type_name":"Prod","value":"v2"}},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v2"}},"level_parameters":[],"name":"LexLeanStd.Text.splitStep","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"UInt8"}},{"borrow":false,"id":"v2","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}}],"recursive":false,"type":{"codomain":{"codomain":{"codomain":{"arguments":[{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"List"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"UInt8"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"body":{"id":"v19","kind":"return"},"id":"v19","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v18","kind":"fvar"}],"function":"v10","kind":"apply"}},"id":"v18","kind":"let","type":{"kind":"const","levels":["1"],"name":"PUnit"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Unit.unit"}},"constructor":"Option.none","kind":"constructor","parameters":[]},{"code":{"body":{"id":"v21","kind":"return"},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v20","kind":"fvar"}],"function":"v6","kind":"apply"}},"constructor":"Option.some","kind":"constructor","parameters":[{"borrow":false,"id":"v20","type":{"kind":"const","levels":[],"name":"ByteArray"}}]}],"discriminant":"v17","kind":"cases","result_type":{"kind":"const","levels":[],"name":"Bool"},"type_name":"Option"},"id":"v17","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v11","kind":"fvar"},{"id":"v0","kind":"fvar"},{"id":"v14","kind":"fvar"},{"id":"v16","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.slice"}},"id":"v16","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v15","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"id":"v14","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v13"}},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v12","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v12","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"id":"v11","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instSliceableByteArray"}},"id":"v10","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"arguments":[],"function":"v7","kind":"apply"}},"declaration":{"id":"v7","parameters":[{"borrow":false,"id":"v8","type":{"kind":"const","levels":["1"],"name":"PUnit"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":["1"],"name":"PUnit"},"kind":"arrow"},"value":{"body":{"id":"v9","kind":"return"},"id":"v9","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.false"}}},"kind":"fun"},"id":"v6","kind":"let","type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"arguments":[],"function":"v2","kind":"apply"}},"declaration":{"id":"v2","parameters":[{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"type":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"value":{"body":{"body":{"id":"v5","kind":"return"},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v4","kind":"fvar"},{"id":"v3","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.equal"}},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":["0"],"name":"BEq"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"ByteArray.instBEq"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.startsWith","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Bool"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v7","kind":"return"},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"ByteArray"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v4","kind":"fvar"},{"id":"v6","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.sliceOr"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v5","kind":"fvar"},{"id":"v2","kind":"fvar"},{"id":"v4","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v5","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v3","kind":"apply"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v2","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.trimStart"}},"id":"v2","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[],"function":"v1","kind":"apply"}},"id":"v1","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.trimEnd"}},"level_parameters":[],"name":"LexLeanStd.Text.trim","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"kind":"const","levels":[],"name":"ByteArray"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"id":"v26","kind":"return"},"id":"v26","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v25"}},"id":"v25","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v1","kind":"fvar"},{"id":"v24","kind":"fvar"},{"id":"v24","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}},"id":"v24","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"id":"v23","kind":"fvar"},{"id":"v0","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.length"}},"id":"v23","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"ByteArray"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"LexLeanRuntime.instLengthableByteArray"}},"declaration":{"id":"v1","parameters":[{"borrow":false,"id":"v2","type":{"kind":"const","levels":[],"name":"Nat"}}],"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v10","kind":"return"},"id":"v10","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v9","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v20","kind":"return"},"id":"v20","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v19","type":{"kind":"erased"}}]},{"code":{"body":{"id":"v22","kind":"return"},"id":"v22","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v16","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v21","type":{"kind":"erased"}}]}],"discriminant":"v18","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v18","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v17","kind":"fvar"},{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v17","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v16","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.spaceAt"}},"id":"v16","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v12","kind":"fvar"},{"id":"v2","kind":"fvar"},{"id":"v15","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanRuntime.subtract"}},"id":"v15","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v14"}},"id":"v14","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v13","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v13","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v12","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Sub"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instSubNat"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v11","type":{"kind":"erased"}}]}],"discriminant":"v8","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v8","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v6","kind":"fvar"},{"id":"v7","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v7","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v6","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v5","kind":"fvar"},{"id":"v2","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.blt"}},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v4"}},"id":"v4","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v3","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v3","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.trimEnd","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}}],"recursive":false,"type":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v27","kind":"return"},"id":"v27","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"Prod","value":"v26"}},"id":"v26","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Bool"}],"head":{"kind":"const","levels":["0","0"],"name":"Prod"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v2","kind":"fvar"},{"id":"v1","kind":"fvar"},{"id":"v25","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanCollections.iterateUntil"}},"id":"v25","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v24"}},"id":"v24","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v23","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v23","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"0"}}},"declaration":{"id":"v2","parameters":[{"borrow":false,"id":"v3","type":{"kind":"const","levels":[],"name":"Nat"}}],"type":{"codomain":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"body":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v8","kind":"return"},"id":"v8","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v7","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"alternatives":[{"code":{"body":{"id":"v13","kind":"return"},"id":"v13","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}}],"kind":"const","levels":["0"],"name":"Option.none"}},"constructor":"Decidable.isFalse","kind":"constructor","parameters":[{"borrow":false,"id":"v12","type":{"kind":"erased"}}]},{"code":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"body":{"id":"v22","kind":"return"},"id":"v22","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v21","kind":"fvar"}],"kind":"const","levels":["0"],"name":"Option.some"}},"id":"v21","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"arguments":[{"id":"v3","kind":"fvar"},{"id":"v20","kind":"fvar"}],"function":"v17","kind":"apply"}},"id":"v20","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"index":0,"kind":"projection","type_name":"OfNat","value":"v19"}},"id":"v19","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"any"}],"head":{"kind":"const","levels":["0"],"name":"OfNat"},"kind":"app"},"value":{"arguments":[{"id":"v18","kind":"fvar"}],"kind":"const","levels":[],"name":"instOfNatNat"}},"id":"v18","kind":"let","type":{"kind":"const","levels":[],"name":"Nat"},"value":{"kind":"literal","literal":{"kind":"nat","value":"1"}}},"id":"v17","kind":"let","type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"value":{"index":0,"kind":"projection","type_name":"HAdd","value":"v16"}},"id":"v16","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"},{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0","0","0"],"name":"HAdd"},"kind":"app"},"value":{"arguments":[{"kind":"type","type":{"kind":"const","levels":[],"name":"Nat"}},{"id":"v15","kind":"fvar"}],"kind":"const","levels":["0"],"name":"instHAdd"}},"id":"v15","kind":"let","type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Add"},"kind":"app"},"value":{"arguments":[],"kind":"const","levels":[],"name":"instAddNat"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v14","type":{"kind":"erased"}}]}],"discriminant":"v11","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v11","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v10","kind":"fvar"},{"id":"v5","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v10","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v0","kind":"fvar"},{"id":"v3","kind":"fvar"}],"kind":"const","levels":[],"name":"LexLeanStd.Text.spaceAt"}},"constructor":"Decidable.isTrue","kind":"constructor","parameters":[{"borrow":false,"id":"v9","type":{"kind":"erased"}}]}],"discriminant":"v6","kind":"cases","result_type":{"arguments":[{"kind":"const","levels":[],"name":"Nat"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"type_name":"Decidable"},"id":"v6","kind":"let","type":{"arguments":[{"kind":"erased"}],"head":{"kind":"const","levels":[],"name":"Decidable"},"kind":"app"},"value":{"arguments":[{"id":"v4","kind":"fvar"},{"id":"v5","kind":"fvar"}],"kind":"const","levels":[],"name":"instDecidableEqBool"}},"id":"v5","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[],"kind":"const","levels":[],"name":"Bool.true"}},"id":"v4","kind":"let","type":{"kind":"const","levels":[],"name":"Bool"},"value":{"arguments":[{"id":"v3","kind":"fvar"},{"id":"v1","kind":"fvar"}],"kind":"const","levels":[],"name":"Nat.blt"}}},"kind":"fun"},"level_parameters":[],"name":"LexLeanStd.Text.trimStart","parameters":[{"borrow":false,"id":"v0","type":{"kind":"const","levels":[],"name":"ByteArray"}},{"borrow":false,"id":"v1","type":{"kind":"const","levels":[],"name":"Nat"}}],"recursive":false,"type":{"codomain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"ByteArray"},"kind":"arrow"}}],"erased":[],"externals":[{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Add"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Array"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.GetElem","name":"Array.instGetElem?NatLtSize"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"BEq"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Bool"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Bool.false"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Bool.true"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"ByteArray"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"ByteArray.data"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Data.ByteArray.Basic","name":"ByteArray.extract"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Data.ByteArray.Basic","name":"ByteArray.fastAppend"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Data.ByteArray.Basic","name":"ByteArray.instBEq"},{"computable":true,"generates_code":true,"kind":"constructor","module":"Init.Prelude","name":"ByteArray.mk"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"ByteArray.size"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Decidable"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Decidable.isFalse"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Decidable.isTrue"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.GetElem","name":"GetElem?"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"HAdd"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"HSub"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"List"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"List.cons"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"List.foldl"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"List.nil"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"List.toArray"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Nat"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"Nat.ble"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Data.Nat.Basic","name":"Nat.blt"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"Nat.decLe"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Nat.succ"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Nat.zero"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"OfNat"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Option"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Option.none"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Option.some"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"PUnit"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Prod"},{"computable":true,"generates_code":false,"kind":"constructor","module":"Init.Prelude","name":"Prod.mk"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"Sub"},{"computable":true,"generates_code":false,"kind":"inductive","module":"Init.Prelude","name":"UInt8"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Data.UInt.BasicAux","name":"UInt8.instOfNat"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"Unit.unit"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instAddNat"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instBEqOfDecidableEq"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instDecidableEqBool"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instDecidableEqUInt8"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instHAdd"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instHSub"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instOfNatNat"},{"computable":true,"generates_code":true,"kind":"definition","module":"Init.Prelude","name":"instSubNat"}],"inductives":[{"constructors":[{"fields":1,"index":0,"name":"LexLeanRuntime.Appendable.mk","parameters":1,"type":{"codomain":{"codomain":{"arguments":[{"index":1,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Appendable"},"kind":"app"},"domain":{"codomain":{"codomain":{"index":2,"kind":"bvar"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"domain":{"index":0,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}}],"indices":0,"name":"LexLeanRuntime.Appendable","parameters":1,"recursive":false},{"constructors":[{"fields":1,"index":0,"name":"LexLeanRuntime.Indexable.mk","parameters":2,"type":{"codomain":{"codomain":{"codomain":{"arguments":[{"index":2,"kind":"bvar"},{"index":1,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Indexable"},"kind":"app"},"domain":{"codomain":{"codomain":{"arguments":[{"index":2,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"index":1,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}}],"indices":0,"name":"LexLeanRuntime.Indexable","parameters":2,"recursive":false},{"constructors":[{"fields":1,"index":0,"name":"LexLeanRuntime.Lengthable.mk","parameters":1,"type":{"codomain":{"codomain":{"arguments":[{"index":1,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Lengthable"},"kind":"app"},"domain":{"codomain":{"kind":"const","levels":[],"name":"Nat"},"domain":{"index":0,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}}],"indices":0,"name":"LexLeanRuntime.Lengthable","parameters":1,"recursive":false},{"constructors":[{"fields":1,"index":0,"name":"LexLeanRuntime.Sliceable.mk","parameters":1,"type":{"codomain":{"codomain":{"arguments":[{"index":1,"kind":"bvar"}],"head":{"kind":"const","levels":[],"name":"LexLeanRuntime.Sliceable"},"kind":"app"},"domain":{"codomain":{"codomain":{"codomain":{"arguments":[{"index":3,"kind":"bvar"}],"head":{"kind":"const","levels":["0"],"name":"Option"},"kind":"app"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"kind":"const","levels":[],"name":"Nat"},"kind":"arrow"},"domain":{"index":0,"kind":"bvar"},"kind":"arrow"},"kind":"arrow"},"domain":{"kind":"sort","level":"1"},"kind":"arrow"}}],"indices":0,"name":"LexLeanRuntime.Sliceable","parameters":1,"recursive":false}],"lean":{"githash":"f054605aea4b840552cca2e725580bffd1e1b704","version":"4.32.1"},"roots":["LexLeanStd.Text.startsWith","LexLeanStd.Text.endsWith","LexLeanStd.Text.trim","LexLeanStd.Text.splitOn","LexLeanStd.Text.lines","LexLeanStd.Text.joinWith","LexLeanStd.Text.find"],"spec":"lexlean/compiler-input/2"} diff --git a/stdlib/lake-manifest.json b/stdlib/lake-manifest.json new file mode 100644 index 0000000000..d9a7bbb3a9 --- /dev/null +++ b/stdlib/lake-manifest.json @@ -0,0 +1,6 @@ +{"version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [], + "name": "stdlib_host", + "lakeDir": ".lake", + "fixedToolchain": false} diff --git a/stdlib/lakefile.toml b/stdlib/lakefile.toml new file mode 100644 index 0000000000..1901e8d17f --- /dev/null +++ b/stdlib/lakefile.toml @@ -0,0 +1,2 @@ +name = "stdlib_host" +version = "0.1.0" diff --git a/stdlib/lean-toolchain b/stdlib/lean-toolchain new file mode 100644 index 0000000000..2b61957be5 --- /dev/null +++ b/stdlib/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.32.1 diff --git a/stdlib/lexlean.lock b/stdlib/lexlean.lock new file mode 100644 index 0000000000..1b7ace15b6 --- /dev/null +++ b/stdlib/lexlean.lock @@ -0,0 +1,47 @@ +spec = "lexlean/lock/2" +language = "1.2" +compiler_semantics = "7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e" +project_config_sha256 = "e7fcfa884a8d0dcabfa2292f1bca96a530b17e56a96f4f68ff7eac749ba2b0c4" +lean_toolchain = "leanprover/lean4:v4.32.1" + +[[workspace_file]] +path = "lake-manifest.json" +sha256 = "56e2ea627849a53364b38bcc31443b42b321167ec74e189ac95ff8edd8c87665" + +[[workspace_file]] +path = "lakefile.toml" +sha256 = "0ed43ca31866dc005a09bc7573c78fcabe669050ddab81e20f0f0624f4806074" + +[[workspace_file]] +path = "lean-toolchain" +sha256 = "8e3538e0ab5f81a3ee04927d8838c8c674e0e112838b4b3ce87ec218143276af" + +[[package]] +id = "lexlean.core" +version = "1.2.0" +kind = "builtin" +source = "embedded" +revision = "compiler-semantics" +tree_sha256 = "827317cae68c162f3a96c8a8de4e53ab348e7d3724fd2b834fa85ecde1a1b392" +manifest_sha256 = "271079763d269cc873531f515e56da960cd6321393b9460ff0e617666fa01d71" +imports = [] + +[[package]] +id = "lexlean.std.bool" +version = "1.2.0" +kind = "builtin" +source = "embedded" +revision = "compiler-semantics" +tree_sha256 = "3bc0fb09d706ffa7d5a1363302ea87c049acc7c7dcafde63c62682620c11be9b" +manifest_sha256 = "de58de2cf18a7a5a62d8c20649139d6dfe1f7b16b3130c75f150fbac5440a71e" +imports = ["lexlean.core@1.2.0"] + +[[package]] +id = "lexlean.std.nat" +version = "1.2.0" +kind = "builtin" +source = "embedded" +revision = "compiler-semantics" +tree_sha256 = "e0db021e01b91d651c43921d66f6b0023c8efbf17cac2ec53192ce5305e4e1ac" +manifest_sha256 = "6fb446b39e3c1c18a5f10cfa1f7aa2bd431837719eb0eb7489aadf452c9420a7" +imports = ["lexlean.core@1.2.0", "lexlean.std.bool@1.2.0"] diff --git a/stdlib/lexlean.toml b/stdlib/lexlean.toml new file mode 100644 index 0000000000..1f6b9be2cb --- /dev/null +++ b/stdlib/lexlean.toml @@ -0,0 +1,27 @@ +spec = "lexlean/project/1" +name = "stdlib" +language = "1.2" +module_prefix = "LexLeanStd" +source_roots = ["src"] +entrypoints = ["src/Text.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/stdlib/src/Text.lex.tex b/stdlib/src/Text.lex.tex new file mode 100755 index 0000000000..0663a47750 --- /dev/null +++ b/stdlib/src/Text.lex.tex @@ -0,0 +1,174 @@ +\begin{lexlean}{Text} +\useglossary{lexlean.std.nat@1.2.0} +\title{Natural number addition} +\begin{semanticmodule} +definition{ + name: isSpace, + parameters: [byte : UInt8], + result: Bool, + body: ((((prim equal byte (32 : UInt8) : Bool) || (prim equal byte (9 : UInt8) : Bool)) || (prim equal byte (10 : UInt8) : Bool)) || ((prim equal byte (12 : UInt8) : Bool) || (prim equal byte (13 : UInt8) : Bool))), + executable: true +} + +definition{ + name: byteAt, + parameters: [subject : Bytes, position : Nat], + result: (Option UInt8), + body: (prim index subject position : (Option UInt8)), + executable: true +} + +definition{ + name: spaceAt, + parameters: [subject : Bytes, position : Nat], + result: Bool, + body: (match (byteAt subject position) + | Option.some byte => (isSpace byte) + | Option.none => false), + executable: true +} + +definition{ + name: sliceOr, + parameters: [subject : Bytes, start : Nat, count : Nat], + result: Bytes, + body: (match (prim slice subject start count : (Option Bytes)) + | Option.some piece => piece + | Option.none => 0x), + executable: true +} + +definition{ + name: startsWith, + parameters: [subject : Bytes, prefix : Bytes], + result: Bool, + body: (match (prim slice subject 0 (prim length prefix : Nat) : (Option Bytes)) + | Option.some head => (prim equal head prefix : Bool) + | Option.none => false), + executable: true, + production: {effects: [allocation], targets: [rust-std]} +} + +definition{ + name: endsWith, + parameters: [subject : Bytes, suffix : Bytes], + result: Bool, + body: (let total : Nat := (prim length subject : Nat); (let size : Nat := (prim length suffix : Nat); (if (size <=? total) then (match (prim slice subject (prim subtract total size : Nat) size : (Option Bytes)) + | Option.some tail => (prim equal tail suffix : Bool) + | Option.none => false) else false))), + executable: true, + production: {effects: [allocation], targets: [rust-std]} +} + +definition{ + name: trimEnd, + parameters: [subject : Bytes], + result: Nat, + body: (first (prim iterate_until (fun [subject] (end : Nat) => (if (0 (if (start (cons piece reversed)) (nil Bytes) pieces : (List Bytes)), + executable: true +} + +definition{ + name: splitStep, + parameters: [subject : Bytes, delimiter : UInt8, state : (Nat * (Nat * (List Bytes)))], + result: (Option (Nat * (Nat * (List Bytes)))), + body: (let position : Nat := (first state); (let start : Nat := (first (second state)); (let pieces : (List Bytes) := (second (second state)); (match (byteAt subject position) + | Option.some byte => (if (prim equal byte delimiter : Bool) then (ctor Option.some [(Nat * (Nat * (List Bytes)))] ((position + 1), ((position + 1), (cons (sliceOr subject start (prim subtract position start : Nat)) pieces)))) else (ctor Option.some [(Nat * (Nat * (List Bytes)))] ((position + 1), (start, pieces)))) + | Option.none => (ctor Option.none [(Nat * (Nat * (List Bytes)))]))))), + executable: true +} + +definition{ + name: splitOn, + parameters: [subject : Bytes, delimiter : UInt8], + result: (List Bytes), + body: (let total : Nat := (prim length subject : Nat); (let final : (Nat * (Nat * (List Bytes))) := (first (prim iterate_until (fun [delimiter, subject] (state : (Nat * (Nat * (List Bytes)))) => (splitStep subject delimiter state)) total (0, (0, (nil Bytes))) : ((Nat * (Nat * (List Bytes))) * Bool))); (let start : Nat := (first (second final)); (reverse (cons (sliceOr subject start (prim subtract total start : Nat)) (second (second final))))))), + executable: true, + production: {effects: [allocation, overflow, recursion], targets: [rust-std]} +} + +definition{ + name: chomp, + parameters: [line : Bytes], + result: Bytes, + body: (if (endsWith line 0x0d) then (sliceOr line 0 (prim subtract (prim length line : Nat) 1 : Nat)) else line), + executable: true +} + +definition{ + name: lineStep, + parameters: [subject : Bytes, state : (Nat * (Nat * (List Bytes)))], + result: (Option (Nat * (Nat * (List Bytes)))), + body: (let position : Nat := (first state); (let start : Nat := (first (second state)); (let pieces : (List Bytes) := (second (second state)); (match (byteAt subject position) + | Option.some byte => (if (prim equal byte (10 : UInt8) : Bool) then (ctor Option.some [(Nat * (Nat * (List Bytes)))] ((position + 1), ((position + 1), (cons (chomp (sliceOr subject start (prim subtract position start : Nat))) pieces)))) else (ctor Option.some [(Nat * (Nat * (List Bytes)))] ((position + 1), (start, pieces)))) + | Option.none => (ctor Option.none [(Nat * (Nat * (List Bytes)))]))))), + executable: true +} + +definition{ + name: lines, + parameters: [subject : Bytes], + result: (List Bytes), + body: (let total : Nat := (prim length subject : Nat); (let final : (Nat * (Nat * (List Bytes))) := (first (prim iterate_until (fun [subject] (state : (Nat * (Nat * (List Bytes)))) => (lineStep subject state)) total (0, (0, (nil Bytes))) : ((Nat * (Nat * (List Bytes))) * Bool))); (let start : Nat := (first (second final)); (let pieces : (List Bytes) := (second (second final)); (if (start (match joined + | Option.none => (ctor Option.some [Bytes] piece) + | Option.some sofar => (ctor Option.some [Bytes] (prim append (prim append sofar separator : Bytes) piece : Bytes)))) (ctor Option.none [Bytes]) pieces : (Option Bytes)) + | Option.some joined => joined + | Option.none => 0x), + executable: true, + production: {effects: [allocation, recursion], targets: [rust-std]} +} + +definition{ + name: matchAt, + parameters: [subject : Bytes, needle : Bytes, position : Nat], + result: Bool, + body: (match (prim slice subject position (prim length needle : Nat) : (Option Bytes)) + | Option.some window => (prim equal window needle : Bool) + | Option.none => false), + executable: true +} + +definition{ + name: find, + parameters: [subject : Bytes, needle : Bytes], + result: (Option Nat), + body: (let total : Nat := (prim length subject : Nat); (let size : Nat := (prim length needle : Nat); (let position : Nat := (first (prim iterate_until (fun [needle, size, subject, total] (position : Nat) => (if (matchAt subject needle position) then (ctor Option.none [Nat]) else (if ((position + size) = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +pub fn f0(v0: Bytes, v1: Bytes) -> bool { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: u64 = { + let a2 = v1.clone(); + length_bytes(a2) + }; + let a3 = v3; + let a4 = v2; + if nat_le(a3, a4) { + let m10 = { + let a7 = v0; + let a8 = { + let a5 = v2; + let a6 = v3; + nat_sub(a5, a6) + }; + let a9 = v3; + slice_bytes(a7, a8, a9) + }; + match m10 { + None => { + false + } + Some(v4) => { + let a11 = v4; + let a12 = v1; + equal(a11, a12) + } + } + } else { + false + } +} + +pub fn run(p0: Bytes, p1: Bytes) -> bool { + f0(p0, p1) +} diff --git a/tests/production-export/stdlib/packages/rust-std/find/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/find/Cargo.toml new file mode 100644 index 0000000000..509b60fcab --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/find/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "find" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" diff --git a/tests/production-export/stdlib/packages/rust-std/find/package.json b/tests/production-export/stdlib/packages/rust-std/find/package.json new file mode 100644 index 0000000000..6f4cc54d0d --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/find/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..28864fb22e --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/find/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"65b8766beaad3445a34057c23351f9454db56cef4c61b2bdb18735c4f186f1d4","src/lib.rs":"457794cebfb5131f4e57731a77bbff0259d7a15f1860c012d6898cd1c104d310"},"name":"find","profile":"rust-std","program":"2313c3ad3e05e24d6b6ceb3617928e0fcbc7caab758cb085cefc5ca51fb5e178","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/find/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/find/src/lib.rs new file mode 100644 index 0000000000..4659e22eb4 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/find/src/lib.rs @@ -0,0 +1,398 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes, u64, Bytes, u64), +} + +impl Fn0 { + pub fn apply(&self, p0: u64) -> R> { + match self { + Fn0::F2(k0, k1, k2, k3) => f2(k0.clone(), *k1, k2.clone(), *k3, p0), + } + } +} + +pub fn f0(v0: Bytes, v1: Bytes) -> R> { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: u64 = { + let a2 = v1.clone(); + length_bytes(a2) + }; + let v4: u64 = { + let (h3, _) = f1(Fn0::F2(v1.clone(), v3, v0.clone(), v2), { + let a4 = v2; + let a5 = 1u64; + nat_add(a4, a5)? + }, 0u64)?; + h3 + }; + if f3(v0, v1, v4) { + Ok(Some(v4)) + } else { + Ok(None::) + } +} + +pub fn f1(v0: Fn0, v1: u64, v2: u64) -> R<(u64, bool)> { + let m6 = v1; + if m6 == 0 { + Ok((v2, false)) + } else { + let v3 = m6 - 1; + let m8 = { + let c7: Fn0 = v0.clone(); + c7.apply(v2)? + }; + match m8 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: Bytes, v1: u64, v2: Bytes, v3: u64, v4: u64) -> R> { + if f3(v2, v0, v4) { + Ok(None::) + } else { + let a11 = { + let a9 = v4; + let a10 = v1; + nat_add(a9, a10)? + }; + let a12 = v3; + if nat_lt(a11, a12) { + Ok(Some({ + let a13 = v4; + let a14 = 1u64; + nat_add(a13, a14)? + })) + } else { + Ok(None::) + } + } +} + +pub fn f3(v0: Bytes, v1: Bytes, v2: u64) -> bool { + let m19 = { + let a16 = v0; + let a17 = v2; + let a18 = { + let a15 = v1.clone(); + length_bytes(a15) + }; + slice_bytes(a16, a17, a18) + }; + match m19 { + None => { + false + } + Some(v3) => { + let a20 = v3; + let a21 = v1; + equal(a20, a21) + } + } +} + +pub fn run(p0: Bytes, p1: Bytes) -> R> { + f0(p0, p1) +} diff --git a/tests/production-export/stdlib/packages/rust-std/join_with/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/join_with/Cargo.toml new file mode 100644 index 0000000000..088712dd77 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/join_with/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "join_with" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" 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 new file mode 100644 index 0000000000..e47b1095ac --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/join_with/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..20029acce9 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/join_with/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"5b8c1edac95e10481210f741989077b0b33bafb42f71c257d0baa28de2931790","src/lib.rs":"53ca1a20dd060557588c5f5676af74172b47b5f34873ee25bf20efbb5ca85d33"},"name":"join_with","profile":"rust-std","program":"96422dc4f1829feeb2a75f4c45d41bdd503b091eabab116da5cadc270be9752a","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/join_with/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/join_with/src/lib.rs new file mode 100644 index 0000000000..39990c01e4 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/join_with/src/lib.rs @@ -0,0 +1,356 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: Option, p1: Bytes) -> Option { + match self { + Fn0::F2(k0) => f2(k0.clone(), p0, p1), + } + } +} + +pub fn f0(v0: List, v1: Bytes) -> Bytes { + let m1 = f1(Fn0::F2(v1), None::, v0); + match m1 { + None => { + Bytes::lit(&[]) + } + Some(v2) => { + v2 + } + } +} + +pub fn f1(v0: Fn0, v1: Option, v2: List) -> Option { + let m2 = v2; + match m2.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f1(v0.clone(), { + let c3: Fn0 = v0; + c3.apply(v1, v3) + }, v4) + } + } +} + +pub fn f2(v0: Bytes, v1: Option, v2: Bytes) -> Option { + let m4 = v1; + match m4 { + None => { + Some(v2) + } + Some(v3) => { + Some({ + let a7 = { + let a5 = v3; + let a6 = v0; + append_bytes(a5, a6) + }; + let a8 = v2; + append_bytes(a7, a8) + }) + } + } +} + +pub fn run(p0: List, p1: Bytes) -> Bytes { + f0(p0, p1) +} diff --git a/tests/production-export/stdlib/packages/rust-std/lines/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/lines/Cargo.toml new file mode 100644 index 0000000000..e6c7a529a0 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/lines/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "lines" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" diff --git a/tests/production-export/stdlib/packages/rust-std/lines/package.json b/tests/production-export/stdlib/packages/rust-std/lines/package.json new file mode 100644 index 0000000000..3f79669982 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/lines/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..2090cdce28 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/lines/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"8784e433d55c1014c3ef57c25eb97e52b822f442912c6afef13bec448b09bbc4","src/lib.rs":"3464baef6c8989e7f3ef0440082437927fdc5bf55b7b334222d8bacdceae80c5"},"name":"lines","profile":"rust-std","program":"841e8e419e8f4303b2680c83d2a7229758e0bfa0204159d69e4a9ed5e30fb1ea","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/lines/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/lines/src/lib.rs new file mode 100644 index 0000000000..e8ff20f471 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/lines/src/lib.rs @@ -0,0 +1,533 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: (u64, (u64, List))) -> R))>> { + match self { + Fn0::F2(k0) => f2(k0.clone(), p0), + } + } +} + +#[derive(Clone)] +pub enum Fn1 { + F7, +} + +impl Fn1 { + pub fn apply(&self, p0: List, p1: Bytes) -> List { + match self { + Fn1::F7 => f7(p0, p1), + } + } +} + +pub fn f0(v0: Bytes) -> R> { + let v1: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v2: (u64, (u64, List)) = { + let (h2, _) = f1(Fn0::F2(v0.clone()), v1, (0u64, (0u64, List::::nil())))?; + h2 + }; + let v3: u64 = { + let (h3, _) = { + let (_, h4) = v2.clone(); + h4 + }; + h3 + }; + let v4: List = { + let (_, h5) = { + let (_, h6) = v2; + h6 + }; + h5 + }; + let a7 = v3; + let a8 = v1; + if nat_lt(a7, a8) { + Ok(f3(List::cons(f4(v0, v3, { + let a9 = v1; + let a10 = v3; + nat_sub(a9, a10) + }), v4))) + } else { + Ok(f3(v4)) + } +} + +pub fn f1(v0: Fn0, v1: u64, v2: (u64, (u64, List))) -> R<((u64, (u64, List)), bool)> { + let m11 = v1; + if m11 == 0 { + Ok((v2, false)) + } else { + let v3 = m11 - 1; + let m13 = { + let c12: Fn0 = v0.clone(); + c12.apply(v2.clone())? + }; + match m13 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: Bytes, v1: (u64, (u64, List))) -> R))>> { + f5(v0, v1) +} + +pub fn f3(v0: List) -> List { + f6(Fn1::F7, List::::nil(), v0) +} + +pub fn f4(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m17 = { + let a14 = v0; + let a15 = v1; + let a16 = v2; + slice_bytes(a14, a15, a16) + }; + match m17 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f5(v0: Bytes, v1: (u64, (u64, List))) -> R))>> { + let v2: u64 = { + let (h18, _) = v1.clone(); + h18 + }; + let v3: u64 = { + let (h19, _) = { + let (_, h20) = v1.clone(); + h20 + }; + h19 + }; + let v4: List = { + let (_, h21) = { + let (_, h22) = v1; + h22 + }; + h21 + }; + let m23 = f8(v0.clone(), v2); + match m23 { + None => { + Ok(None::<(u64, (u64, List))>) + } + Some(v5) => { + let a24 = v5; + let a25 = 10u8; + if equal(a24, a25) { + Ok(Some(({ + let a26 = v2; + let a27 = 1u64; + nat_add(a26, a27)? + }, ({ + let a28 = v2; + let a29 = 1u64; + nat_add(a28, a29)? + }, List::cons(f9(f4(v0, v3, { + let a30 = v2; + let a31 = v3; + nat_sub(a30, a31) + })), v4))))) + } else { + Ok(Some(({ + let a32 = v2; + let a33 = 1u64; + nat_add(a32, a33)? + }, (v3, v4)))) + } + } + } +} + +pub fn f6(v0: Fn1, v1: List, v2: List) -> List { + let m34 = v2; + match m34.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f6(v0.clone(), { + let c35: Fn1 = v0; + c35.apply(v1, v3) + }, v4) + } + } +} + +pub fn f7(v0: List, v1: Bytes) -> List { + List::cons(v1, v0) +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a36 = v0; + let a37 = v1; + index_bytes(a36, a37) +} + +pub fn f9(v0: Bytes) -> Bytes { + if f10(v0.clone(), Bytes::lit(&[0x0d])) { + f4(v0.clone(), 0u64, { + let a39 = { + let a38 = v0; + length_bytes(a38) + }; + let a40 = 1u64; + nat_sub(a39, a40) + }) + } else { + v0 + } +} + +pub fn f10(v0: Bytes, v1: Bytes) -> bool { + let v2: u64 = { + let a41 = v0.clone(); + length_bytes(a41) + }; + let v3: u64 = { + let a42 = v1.clone(); + length_bytes(a42) + }; + let a43 = v3; + let a44 = v2; + if nat_le(a43, a44) { + let m50 = { + let a47 = v0; + let a48 = { + let a45 = v2; + let a46 = v3; + nat_sub(a45, a46) + }; + let a49 = v3; + slice_bytes(a47, a48, a49) + }; + match m50 { + None => { + false + } + Some(v4) => { + let a51 = v4; + let a52 = v1; + equal(a51, a52) + } + } + } else { + false + } +} + +pub fn run(p0: Bytes) -> R> { + f0(p0) +} diff --git a/tests/production-export/stdlib/packages/rust-std/split_on/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/split_on/Cargo.toml new file mode 100644 index 0000000000..b10fb39862 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/split_on/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "split_on" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" 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 new file mode 100644 index 0000000000..9b746a35ca --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/split_on/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..4fbdbfcdc4 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/split_on/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"eec87b90321a716e390db4002e4dfdaa697e6daf4b86d7a2cd07c5f2ac707e2d","src/lib.rs":"d655f10225cbcf659140129f15911ebea1005006b91b542910504454c8155455"},"name":"split_on","profile":"rust-std","program":"338fb203721ebdf49131b19350509614a5e1e84758f7a82903c48bbc472d8dc3","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/split_on/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/split_on/src/lib.rs new file mode 100644 index 0000000000..8e39d81436 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/split_on/src/lib.rs @@ -0,0 +1,474 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F2(u8, Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: (u64, (u64, List))) -> R))>> { + match self { + Fn0::F2(k0, k1) => f2(*k0, k1.clone(), p0), + } + } +} + +#[derive(Clone)] +pub enum Fn1 { + F7, +} + +impl Fn1 { + pub fn apply(&self, p0: List, p1: Bytes) -> List { + match self { + Fn1::F7 => f7(p0, p1), + } + } +} + +pub fn f0(v0: Bytes, v1: u8) -> R> { + let v2: u64 = { + let a1 = v0.clone(); + length_bytes(a1) + }; + let v3: (u64, (u64, List)) = { + let (h2, _) = f1(Fn0::F2(v1, v0.clone()), v2, (0u64, (0u64, List::::nil())))?; + h2 + }; + let v4: u64 = { + let (h3, _) = { + let (_, h4) = v3.clone(); + h4 + }; + h3 + }; + Ok(f3(List::cons(f4(v0, v4, { + let a5 = v2; + let a6 = v4; + nat_sub(a5, a6) + }), { + let (_, h7) = { + let (_, h8) = v3; + h8 + }; + h7 + }))) +} + +pub fn f1(v0: Fn0, v1: u64, v2: (u64, (u64, List))) -> R<((u64, (u64, List)), bool)> { + let m9 = v1; + if m9 == 0 { + Ok((v2, false)) + } else { + let v3 = m9 - 1; + let m11 = { + let c10: Fn0 = v0.clone(); + c10.apply(v2.clone())? + }; + match m11 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f1(v0, v3, v4) + } + } + } +} + +pub fn f2(v0: u8, v1: Bytes, v2: (u64, (u64, List))) -> R))>> { + f5(v1, v0, v2) +} + +pub fn f3(v0: List) -> List { + f6(Fn1::F7, List::::nil(), v0) +} + +pub fn f4(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m15 = { + let a12 = v0; + let a13 = v1; + let a14 = v2; + slice_bytes(a12, a13, a14) + }; + match m15 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f5(v0: Bytes, v1: u8, v2: (u64, (u64, List))) -> R))>> { + let v3: u64 = { + let (h16, _) = v2.clone(); + h16 + }; + let v4: u64 = { + let (h17, _) = { + let (_, h18) = v2.clone(); + h18 + }; + h17 + }; + let v5: List = { + let (_, h19) = { + let (_, h20) = v2; + h20 + }; + h19 + }; + let m21 = f8(v0.clone(), v3); + match m21 { + None => { + Ok(None::<(u64, (u64, List))>) + } + Some(v6) => { + let a22 = v6; + let a23 = v1; + if equal(a22, a23) { + Ok(Some(({ + let a24 = v3; + let a25 = 1u64; + nat_add(a24, a25)? + }, ({ + let a26 = v3; + let a27 = 1u64; + nat_add(a26, a27)? + }, List::cons(f4(v0, v4, { + let a28 = v3; + let a29 = v4; + nat_sub(a28, a29) + }), v5))))) + } else { + Ok(Some(({ + let a30 = v3; + let a31 = 1u64; + nat_add(a30, a31)? + }, (v4, v5)))) + } + } + } +} + +pub fn f6(v0: Fn1, v1: List, v2: List) -> List { + let m32 = v2; + match m32.uncons() { + None => { + v1 + } + Some((v3, v4)) => { + f6(v0.clone(), { + let c33: Fn1 = v0; + c33.apply(v1, v3) + }, v4) + } + } +} + +pub fn f7(v0: List, v1: Bytes) -> List { + List::cons(v1, v0) +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a34 = v0; + let a35 = v1; + index_bytes(a34, a35) +} + +pub fn run(p0: Bytes, p1: u8) -> R> { + f0(p0, p1) +} diff --git a/tests/production-export/stdlib/packages/rust-std/starts_with/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/starts_with/Cargo.toml new file mode 100644 index 0000000000..69026586df --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "starts_with" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" 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 new file mode 100644 index 0000000000..00135b3ea7 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..7605bb4e5b --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"0560bbd795b0d18aa5e54a6e850d5ba891a72eed60586ffd18ba3818a9f06400","src/lib.rs":"e41016d01141f5539ac77f084f9fc0a489ee13b13edf01649d8a018bb2ed968f"},"name":"starts_with","profile":"rust-std","program":"1b124ea56028fd1442abdae2335001fd8074f4ded5f7e2fdfb72349b8cbee66f","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/starts_with/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/starts_with/src/lib.rs new file mode 100644 index 0000000000..912af8cbb0 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/starts_with/src/lib.rs @@ -0,0 +1,318 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +pub fn f0(v0: Bytes, v1: Bytes) -> bool { + let m5 = { + let a2 = v0; + let a3 = 0u64; + let a4 = { + let a1 = v1.clone(); + length_bytes(a1) + }; + slice_bytes(a2, a3, a4) + }; + match m5 { + None => { + false + } + Some(v2) => { + let a6 = v2; + let a7 = v1; + equal(a6, a7) + } + } +} + +pub fn run(p0: Bytes, p1: Bytes) -> bool { + f0(p0, p1) +} diff --git a/tests/production-export/stdlib/packages/rust-std/trim/Cargo.toml b/tests/production-export/stdlib/packages/rust-std/trim/Cargo.toml new file mode 100644 index 0000000000..53efe45f83 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/trim/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "trim" +version = "1.0.0" +edition = "2021" +publish = false + +[lib] +path = "src/lib.rs" + +[lints.rust] +unsafe_code = "forbid" +warnings = "deny" + +[lints.clippy] +all = { level = "deny", priority = -1 } +type_complexity = "allow" +too_many_arguments = "allow" +large_enum_variant = "allow" +result_large_err = "allow" +result_unit_err = "allow" +single_match = "allow" +manual_unwrap_or = "allow" +manual_unwrap_or_default = "allow" +manual_map = "allow" +manual_ok_err = "allow" diff --git a/tests/production-export/stdlib/packages/rust-std/trim/package.json b/tests/production-export/stdlib/packages/rust-std/trim/package.json new file mode 100644 index 0000000000..56105901ef --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/trim/package.json @@ -0,0 +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":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"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 new file mode 100644 index 0000000000..5f016cb5c6 --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/trim/provenance.json @@ -0,0 +1 @@ +{"compiler_semantics":"7c6ad91252b5e1a4d0db2bb0b8fd6bff660b68553b163bd3b5552b4694352d8e","exports":[{"function":0,"name":"run"}],"files":{"Cargo.toml":"177bb2192e3758151d1838757adc34d91380a78d0d3c0d315694c6fac2da6618","src/lib.rs":"f57aaf2f65cc974d6053dbf690da0824652e28ae5e6761eb9bb01cdfe9492067"},"name":"trim","profile":"rust-std","program":"9a47374cdeea9e3296ff6a7908b312ddf5a3243176f7652b57d8fbe92eac8455","runtime":"3041e90e504b052caf830dfc20f8743d30cdb7a0c8e5c460f8b50f314765ea9c","sources":["b4a41a9b6af3776bed9cd860f1a4f2d97971dd33b7353974e4f8537cd0c27ab3"],"spec":"lexlean/rust-provenance/1","version":"1.0.0"} diff --git a/tests/production-export/stdlib/packages/rust-std/trim/src/lib.rs b/tests/production-export/stdlib/packages/rust-std/trim/src/lib.rs new file mode 100644 index 0000000000..5261ad901f --- /dev/null +++ b/tests/production-export/stdlib/packages/rust-std/trim/src/lib.rs @@ -0,0 +1,463 @@ +#![forbid(unsafe_code)] +use core::cmp::Ordering; +use core::sync::atomic::{AtomicU64, Ordering as Memory}; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Overflow; +pub type R = Result; + +static WORK: AtomicU64 = AtomicU64::new(0); +pub fn tick(units: u64) { WORK.fetch_add(units, Memory::Relaxed); } +pub fn work() -> u64 { WORK.load(Memory::Relaxed) } + +pub fn nat_add(a: u64, b: u64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn nat_sub(a: u64, b: u64) -> u64 { a.saturating_sub(b) } +pub fn nat_mul(a: u64, b: u64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn nat_quot(a: u64, b: u64, z: u64) -> u64 { a.checked_div(b).unwrap_or(z) } +pub fn nat_rem(a: u64, b: u64, z: u64) -> u64 { a.checked_rem(b).unwrap_or(z) } +pub fn nat_eq(a: u64, b: u64) -> bool { a == b } +pub fn nat_le(a: u64, b: u64) -> bool { a <= b } +pub fn nat_lt(a: u64, b: u64) -> bool { a < b } +pub fn nat_succ(a: u64) -> R { a.checked_add(1).ok_or(Overflow) } +pub fn int_add(a: i64, b: i64) -> R { a.checked_add(b).ok_or(Overflow) } +pub fn int_sub(a: i64, b: i64) -> R { a.checked_sub(b).ok_or(Overflow) } +pub fn int_mul(a: i64, b: i64) -> R { a.checked_mul(b).ok_or(Overflow) } +pub fn int_neg(a: i64) -> R { a.checked_neg().ok_or(Overflow) } +pub fn int_quot(a: i64, b: i64, z: i64) -> R { if b == 0 { Ok(z) } else { a.checked_div(b).ok_or(Overflow) } } +pub fn int_rem(a: i64, b: i64, z: i64) -> i64 { if b == 0 { z } else { a.wrapping_rem(b) } } +pub fn bool_not(a: bool) -> bool { !a } +pub fn bool_and(a: bool, b: bool) -> bool { a && b } +pub fn bool_or(a: bool, b: bool) -> bool { a || b } + +pub trait Same { fn same(&self, other: &Self) -> bool; } +pub trait Key { fn key(&self, other: &Self) -> Ordering; } +macro_rules! scalar { + ($($t:ty),*) => { $( + impl Same for $t { fn same(&self, other: &Self) -> bool { self == other } } + impl Key for $t { fn key(&self, other: &Self) -> Ordering { self.cmp(other) } } + )* }; +} +scalar!(bool, u8, u16, u32, u64, i8, i16, i32, i64); +impl Same for Ordering { fn same(&self, other: &Self) -> bool { self == other } } +impl Key for (A, B) { + fn key(&self, other: &Self) -> Ordering { + match self.0.key(&other.0) { Ordering::Equal => self.1.key(&other.1), decided => decided } + } +} +pub fn equal(a: T, b: T) -> bool { a.same(&b) } +pub fn compare(a: T, b: T) -> Ordering { a.key(&b) } + +macro_rules! fixed { + ($m:ident, $t:ident) => { + pub mod $m { + pub fn checked_add(a: $t, b: $t) -> Option<$t> { a.checked_add(b) } + pub fn checked_sub(a: $t, b: $t) -> Option<$t> { a.checked_sub(b) } + pub fn checked_mul(a: $t, b: $t) -> Option<$t> { a.checked_mul(b) } + pub fn checked_quot(a: $t, b: $t) -> Option<$t> { a.checked_div(b) } + pub fn bit_and(a: $t, b: $t) -> $t { a & b } + pub fn bit_or(a: $t, b: $t) -> $t { a | b } + pub fn bit_xor(a: $t, b: $t) -> $t { a ^ b } + pub fn bit_not(a: $t) -> $t { !a } + pub fn shift_left(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shl(amount)) } else { None } } + pub fn shift_right(a: $t, amount: u32) -> Option<$t> { if amount < $t::BITS { Some(a.wrapping_shr(amount)) } else { None } } + pub fn convert(a: i128) -> Option<$t> { $t::try_from(a).ok() } + } + }; +} +fixed!(fixed_u8, u8); fixed!(fixed_u16, u16); fixed!(fixed_u32, u32); fixed!(fixed_u64, u64); +fixed!(fixed_i8, i8); fixed!(fixed_i16, i16); fixed!(fixed_i32, i32); fixed!(fixed_i64, i64); +pub fn checked_neg_i8(a: i8) -> Option { a.checked_neg() } +pub fn checked_neg_i16(a: i16) -> Option { a.checked_neg() } +pub fn checked_neg_i32(a: i32) -> Option { a.checked_neg() } +pub fn checked_neg_i64(a: i64) -> Option { a.checked_neg() } + +#[derive(Clone)] +pub struct Str(std::rc::Rc); +impl Str { + pub fn lit(text: &str) -> Str { Str(std::rc::Rc::from(text)) } + pub fn text(&self) -> &str { &self.0 } +} +#[derive(Clone)] +pub struct Bytes(std::rc::Rc<[u8]>); +impl Bytes { + pub fn lit(octets: &[u8]) -> Bytes { Bytes(std::rc::Rc::from(octets)) } + pub fn octets(&self) -> &[u8] { &self.0 } +} + +pub struct Node { head: T, tail: List } +/// A list is a run of cells laid out contiguously, from the newest at the end of a buffer +/// to the oldest at its start, or a cell in front of another list. A `cons` onto a run that +/// owns its buffer alone pushes in place; a `cons` onto any other list is one cell, so +/// building and taking apart a cell is constant work whatever the sharing, and no buffer is +/// written while another list can see it. +pub enum Repr { Nil, Run { buffer: std::rc::Rc>, len: usize }, Cell(std::rc::Rc>) } +pub struct List(Repr); +impl Clone for List { + fn clone(&self) -> Self { + List(match &self.0 { + Repr::Nil => Repr::Nil, + Repr::Run { buffer, len } => Repr::Run { buffer: buffer.clone(), len: *len }, + Repr::Cell(cell) => Repr::Cell(cell.clone()), + }) + } +} +impl List { + fn take(&mut self) -> Repr { std::mem::replace(&mut self.0, Repr::Nil) } +} +impl Drop for Node { + fn drop(&mut self) { + let mut next = match self.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }; + while let Some(cell) = next { // release + match std::rc::Rc::try_unwrap(cell) { + Ok(mut node) => next = match node.tail.take() { Repr::Cell(cell) => Some(cell), _ => None }, + Err(_) => break, + } + } + } +} +impl List { + pub fn nil() -> Self { List(Repr::Nil) } + pub fn cons(head: T, mut tail: List) -> Self { + List(match tail.take() { + Repr::Nil => { + let mut buffer = Vec::with_capacity(16); + buffer.push(head); + Repr::Run { buffer: std::rc::Rc::new(buffer), len: 1 } + } + Repr::Run { mut buffer, len } => { + if let Some(cells) = std::rc::Rc::get_mut(&mut buffer) { + cells.truncate(len); + cells.push(head); + Repr::Run { buffer, len: len + 1 } + } else { + Repr::Cell(std::rc::Rc::new(Node { head, tail: List(Repr::Run { buffer, len }) })) + } + } + rest => Repr::Cell(std::rc::Rc::new(Node { head, tail: List(rest) })), + }) + } + pub fn uncons(&self) -> Option<(T, List)> { + match &self.0 { + Repr::Nil => None, + Repr::Run { buffer, len } => { + let head = buffer[len - 1].clone(); + Some((head, List(if *len == 1 { Repr::Nil } else { Repr::Run { buffer: buffer.clone(), len: len - 1 } }))) + } + Repr::Cell(cell) => Some((cell.head.clone(), cell.tail.clone())), + } + } + /// Walk the items in order, ticking one per item, until `each` says to stop: the cells + /// in front, then the run they end in. + fn walk(&self, each: &mut dyn FnMut(&T) -> bool) { + let mut cursor = self; + while let Repr::Cell(cell) = &cursor.0 { tick(1); if !each(&cell.head) { return; } cursor = &cell.tail; } + if let Repr::Run { buffer, len } = &cursor.0 { + for item in buffer[..*len].iter().rev() { tick(1); if !each(item) { return; } } + } + } + fn items(&self) -> Vec { + let mut out = Vec::new(); + self.walk(&mut |item| { out.push(item.clone()); true }); + out + } + fn onto(items: Vec, tail: List) -> List { + let mut out = tail; + for item in items.into_iter().rev() { tick(1); out = List::cons(item, out); } + out + } +} + +fn chars(text: &str) -> u64 { + let mut count = 0; + for _ in text.chars() { tick(1); count += 1; } + count +} + +impl Same for Str { + fn same(&self, other: &Self) -> bool { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { (None, None) => return true, (a, b) if a != b => return false, _ => {} } + } + } +} +impl Same for Bytes { + fn same(&self, other: &Self) -> bool { tick(1 + self.0.len().min(other.0.len()) as u64); self.0 == other.0 } +} +impl Key for Str { + fn key(&self, other: &Self) -> Ordering { + let mut left = self.0.chars(); + let mut right = other.0.chars(); + loop { + tick(1); + match (left.next(), right.next()) { + (None, None) => return Ordering::Equal, + (None, Some(_)) => return Ordering::Less, + (Some(_), None) => return Ordering::Greater, + (Some(a), Some(b)) => match a.cmp(&b) { Ordering::Equal => {} decided => return decided }, + } + } + } +} + +pub fn append_list(a: List, b: List) -> List { List::onto(a.items(), b) } +pub fn append_bytes(a: Bytes, b: Bytes) -> Bytes { + tick((a.0.len() + b.0.len()) as u64); + let mut out = Vec::with_capacity(a.0.len() + b.0.len()); + out.extend_from_slice(&a.0); + out.extend_from_slice(&b.0); + Bytes(std::rc::Rc::from(out)) +} +pub fn length_list(a: List) -> u64 { + let mut count = 0; + a.walk(&mut |_| { count += 1; true }); + count +} +pub fn length_bytes(a: Bytes) -> u64 { a.0.len() as u64 } +pub fn length_string(a: Str) -> u64 { chars(&a.0) } +pub fn index_list(a: List, i: u64) -> Option { + let mut position = 0; + let mut found = None; + a.walk(&mut |item| { if position == i { found = Some(item.clone()); return false; } position += 1; true }); + found +} +pub fn index_bytes(a: Bytes, i: u64) -> Option { usize::try_from(i).ok().and_then(|i| a.0.get(i)).copied() } +pub fn slice_list(a: List, start: u64, count: u64) -> Option> { + let end = u128::from(start) + u128::from(count); + let mut part = Vec::new(); + let mut position: u128 = 0; + a.walk(&mut |item| { + if position >= end { return false; } + if position >= u128::from(start) { part.push(item.clone()); } + position += 1; + true + }); + if position < end { None } else { Some(List::onto(part, List::nil())) } +} +pub fn slice_bytes(a: Bytes, start: u64, count: u64) -> Option { + let end = u128::from(start) + u128::from(count); + if end > a.0.len() as u128 { return None; } + tick(count); + Some(Bytes::lit(&a.0[start as usize..end as usize])) +} +pub fn utf8_encode(a: Str) -> Bytes { tick(a.0.len() as u64); Bytes::lit(a.0.as_bytes()) } +pub fn utf8_decode(a: Bytes) -> Option { tick(a.0.len() as u64); core::str::from_utf8(&a.0).ok().map(Str::lit) } +pub fn compare_bytes(a: Bytes, b: Bytes) -> Ordering { tick(1 + a.0.len().min(b.0.len()) as u64); a.0.cmp(&b.0) } +pub fn split_exact(text: Str, delimiter: Str, maximum: u32) -> Option> { + if delimiter.0.is_empty() { return None; } + chars(&text.0); + let fields: Vec = text.0.split(&*delimiter.0).map(Str::lit).collect(); + if fields.len() as u128 > u128::from(maximum) { return None; } + Some(List::onto(fields, List::nil())) +} +pub fn join(texts: List, delimiter: Str) -> Str { + let mut out = String::new(); + let mut first = true; + texts.walk(&mut |text| { + if !first { chars(&delimiter.0); out.push_str(&delimiter.0); } + first = false; + chars(&text.0); + out.push_str(&text.0); + true + }); + Str::lit(&out) +} +fn canonical_decimal(text: &str) -> Option> { + let digits = text.strip_prefix('-').unwrap_or(text); + let mut canonical = !digits.is_empty() && (digits == "0" || !digits.starts_with('0')) && text != "-0"; + for c in digits.chars() { tick(1); canonical = canonical && c.is_ascii_digit(); } + if !canonical { return None; } + Some(text.parse::().ok()) +} +pub fn parse_int(text: Str) -> R> { + match canonical_decimal(&text.0) { + None => Ok(None), + Some(Some(n)) => i64::try_from(n).map(Some).map_err(|_| Overflow), + Some(None) => Err(Overflow), + } +} +macro_rules! decimal { + ($t:ident, $format:ident, $parse:ident) => { + pub fn $format(a: $t) -> Str { let text = a.to_string(); tick(text.len() as u64); Str::lit(&text) } + pub fn $parse(text: Str) -> Option<$t> { + match canonical_decimal(&text.0) { Some(Some(n)) => $t::try_from(n).ok(), _ => None } + } + }; +} +decimal!(u8, format_u8, parse_u8); decimal!(u16, format_u16, parse_u16); +decimal!(u32, format_u32, parse_u32); decimal!(u64, format_u64, parse_u64); +decimal!(i8, format_i8, parse_i8); decimal!(i16, format_i16, parse_i16); +decimal!(i32, format_i32, parse_i32); decimal!(i64, format_i64, parse_i64); + +#[derive(Clone)] +pub enum Fn0 { + F5(Bytes), + F6(u64, Bytes), +} + +impl Fn0 { + pub fn apply(&self, p0: u64) -> R> { + match self { + Fn0::F5(k0) => Ok(f5(k0.clone(), p0)), + Fn0::F6(k0, k1) => f6(*k0, k1.clone(), p0), + } + } +} + +pub fn f0(v0: Bytes) -> R { + let v1: u64 = f1(v0.clone())?; + let v2: u64 = f2(v0.clone(), v1)?; + Ok(f3(v0, v2, { + let a1 = v1; + let a2 = v2; + nat_sub(a1, a2) + })) +} + +pub fn f1(v0: Bytes) -> R { + let (h3, _) = f4(Fn0::F5(v0.clone()), { + let a4 = v0.clone(); + length_bytes(a4) + }, { + let a5 = v0; + length_bytes(a5) + })?; + Ok(h3) +} + +pub fn f2(v0: Bytes, v1: u64) -> R { + let (h6, _) = f4(Fn0::F6(v1, v0), v1, 0u64)?; + Ok(h6) +} + +pub fn f3(v0: Bytes, v1: u64, v2: u64) -> Bytes { + let m10 = { + let a7 = v0; + let a8 = v1; + let a9 = v2; + slice_bytes(a7, a8, a9) + }; + match m10 { + None => { + Bytes::lit(&[]) + } + Some(v3) => { + v3 + } + } +} + +pub fn f4(v0: Fn0, v1: u64, v2: u64) -> R<(u64, bool)> { + let m11 = v1; + if m11 == 0 { + Ok((v2, false)) + } else { + let v3 = m11 - 1; + let m13 = { + let c12: Fn0 = v0.clone(); + c12.apply(v2)? + }; + match m13 { + None => { + Ok((v2, true)) + } + Some(v4) => { + f4(v0, v3, v4) + } + } + } +} + +pub fn f5(v0: Bytes, v1: u64) -> Option { + let a14 = 0u64; + let a15 = v1; + if nat_lt(a14, a15) { + if f7(v0, { + let a16 = v1; + let a17 = 1u64; + nat_sub(a16, a17) + }) { + Some({ + let a18 = v1; + let a19 = 1u64; + nat_sub(a18, a19) + }) + } else { + None:: + } + } else { + None:: + } +} + +pub fn f6(v0: u64, v1: Bytes, v2: u64) -> R> { + let a20 = v2; + let a21 = v0; + if nat_lt(a20, a21) { + if f7(v1, v2) { + Ok(Some({ + let a22 = v2; + let a23 = 1u64; + nat_add(a22, a23)? + })) + } else { + Ok(None::) + } + } else { + Ok(None::) + } +} + +pub fn f7(v0: Bytes, v1: u64) -> bool { + let m24 = f8(v0, v1); + match m24 { + None => { + false + } + Some(v2) => { + f9(v2) + } + } +} + +pub fn f8(v0: Bytes, v1: u64) -> Option { + let a25 = v0; + let a26 = v1; + index_bytes(a25, a26) +} + +pub fn f9(v0: u8) -> bool { + let a27 = v0; + let a28 = 32u8; + if if if equal(a27, a28) { + true + } else { + let a29 = v0; + let a30 = 9u8; + equal(a29, a30) + } { + true + } else { + let a31 = v0; + let a32 = 10u8; + equal(a31, a32) + } { + true + } else { + let a33 = v0; + let a34 = 12u8; + if equal(a33, a34) { + true + } else { + let a35 = v0; + let a36 = 13u8; + equal(a35, a36) + } + } +} + +pub fn run(p0: Bytes) -> R { + f0(p0) +} diff --git a/tests/production-export/stdlib/roots.json b/tests/production-export/stdlib/roots.json new file mode 100755 index 0000000000..ad1a30ae16 --- /dev/null +++ b/tests/production-export/stdlib/roots.json @@ -0,0 +1,60 @@ +{ + "roots": [ + { + "name": "starts_with", + "root": "LexLeanStd.Text.startsWith", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "ends_with", + "root": "LexLeanStd.Text.endsWith", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "trim", + "root": "LexLeanStd.Text.trim", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "split_on", + "root": "LexLeanStd.Text.splitOn", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "lines", + "root": "LexLeanStd.Text.lines", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "join_with", + "root": "LexLeanStd.Text.joinWith", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + }, + { + "name": "find", + "root": "LexLeanStd.Text.find", + "targets": [ + "rust-std" + ], + "version": "1.0.0" + } + ] +} diff --git a/xtask/src/audit.rs b/xtask/src/audit.rs index 28d55b5d28..35870eecf6 100644 --- a/xtask/src/audit.rs +++ b/xtask/src/audit.rs @@ -870,7 +870,7 @@ pub fn audit_deferral(root: &Path) -> Result<(), Fail> { root, &[ "crates", "xtask", "language", "schemas", "features", "examples", "model", "tests", - "lean", "compiler", + "lean", "compiler", "stdlib", ], &[ ".rs", ".toml", ".json", ".md", ".feature", ".lex.tex", ".lean", ".txt", ".sh", @@ -1074,7 +1074,9 @@ pub fn audit_errors(root: &Path, model: &repo_model::Model) -> Result<(), Fail> let mut mention_files = Vec::new(); gather( root, - &["tests", "features", "examples", "model", "compiler"], + &[ + "tests", "features", "examples", "model", "compiler", "stdlib", + ], &[".toml", ".json", ".feature", ".md", ".txt"], &mut mention_files, ); diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 0789e73148..aaeafeff8f 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -147,6 +147,13 @@ fn example_dirs(root: &Path) -> Result, Fail> { return Err("§17.14: the compiler project is missing".into()); } dirs.push(compiler); + // The standard library (§17.22) is source of the product under the same + // gates. + let stdlib = root.join("stdlib"); + if !stdlib.join("lexlean.toml").exists() { + return Err("§17.22: the standard library project is missing".into()); + } + dirs.push(stdlib); Ok(dirs) } diff --git a/xtask/src/spec_links.rs b/xtask/src/spec_links.rs index 462cc4c5b1..37292d0383 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() != 393 { + return Err(format!("RP-07: the §31 table has {} rows, not 393", 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.